public void CreateChunk(int x, int y, int z)
{
Vector3Int worldPos = new Vector3Int(x, y, z);
var chunkObject = Instantiate(ChunkPrefab, new Vector3(x, y, z), Quaternion.Euler(Vector3.zero), transform) as GameObject;
Chunk newChunk = chunkObject.GetComponent <Chunk>();
newChunk.pos = worldPos;
newChunk.world = this;
newChunk.name = $"{worldPos.x}_{worldPos.y}_{worldPos.z}";
chunks.Add(worldPos, newChunk);
bool loaded = Serialization.Load(newChunk);
if (loaded)
{
return;
}
var terrainGenerationMethod = new TerrainGeneration(BlocsDefinition);
newChunk = terrainGenerationMethod.GenerateChunk3D(newChunk);
}
void UpdateTerrains()
{
Vector3 cameraPosition = cam.Position;
currentTerrain = (int)(cameraPosition.z / terrainSize.y);
if (currentTerrain > previousTerrain)
{
Destroy(terrains[TerrainPosition.Bot].gameObject);
int size = terrains.Count - 1;
for (int i = 0; i < size; i++)
{
terrains[(TerrainPosition)i] = terrains[(TerrainPosition)i + 1];
}
GameObject regionClone = PrefabController.CreateGameObject(PrefabController.Prefab.Terrain);
Vector3 position = regionClone.transform.position;
position.z = terrains[(TerrainPosition)((int)TerrainPosition.Top - 1)].Position.z + terrainSize.y;
regionClone.transform.position = position;
TerrainGeneration terrain = regionClone.GetComponent <TerrainGeneration>();
terrain.Setup(halfRegionSize);
terrains[TerrainPosition.Top] = terrain;
}
previousTerrain = currentTerrain;
}
/// <summary>
/// Places objects randomly on a given chunk
/// </summary>
/// <param name="chunk"></param>
public static void PlaceObjectsAtChunk(TerrainChunk chunk)
{
System.Random random = new System.Random(TerrainGeneration.instance.Seed + chunk.ChunkPosition.GetHashCode());
for (int i = 0; i < instance.gameObjectLayers.Length; i++)
{
if (!instance.gameObjectLayers[i].Enabled || chunk.ChunkObjects[i].GameObjects.Count > 0)
{
continue;
}
for (int o = 0; o < instance.gameObjectLayers[i].NumberPerChunk; o++)
{
float xPos = MathUtility.GetRandomNumber(random, chunk.Position.x, chunk.Position.x + TerrainGeneration.instance.ChunkSize);
float zPos = MathUtility.GetRandomNumber(random, chunk.Position.z, chunk.Position.z + TerrainGeneration.instance.ChunkSize);
float yPos = TerrainGeneration.SampleHeightMapWorld(xPos, zPos);
if (yPos >= instance.gameObjectLayers[i].MinHeight && yPos < instance.gameObjectLayers[i].MaxHeight)
{
Vector3 newPosition = new Vector3(xPos, yPos, zPos);
GameObject placedObject = instance.gameObjectLayers[i].ObjectsWaiting.Dequeue();
placedObject.transform.position = newPosition;
placedObject.SetActive(true);
chunk.ChunkObjects[i].GameObjects.Add(placedObject);
}
}
}
}
void generatePerson(TerrainGeneration TG)
{
Vector3 point = new Vector3(dimensions.x / 2, 0f, dimensions.z / 2);
point.y = TG.terrain.SampleHeight(point) + 2.1f;
Instantiate(person, point, Quaternion.identity);
}
void drawMesh()
{
Mesh mesh = TerrainGeneration.generateMesh(noiseMap, heightSacle);
GetComponent <MeshFilter>().sharedMesh = mesh;
GetComponent <MeshRenderer>().sharedMaterial.mainTexture = texture;
}
private void Awake()
{
if (this.terrainGeneration == null)
{
this.terrainGeneration = GameObject.Find("TerrainGeneration").GetComponent <TerrainGeneration>();
}
}
void Update()
{
TerrainGeneration m = FindObjectOfType <TerrainGeneration>();
float boundsY = m.ChunkSize * m.NumOfChunks.y;
boundsY += boundsY * 0.2f; //20% buffer to ensure texture doesnt wrap
//update textures
if (TextureMesh)
{
Init();
UpdateTexture();
//set texture
mat.SetFloat("boundsY", boundsY);
mat.SetTexture("ramp", texture);
Vector4 shaderParams = new Vector4(TextureStretch.x, TextureStretch.y, 0.0f, 0.0f);
mat.SetVector("params", shaderParams);
}
else
{
//new blank texture
Texture2D tex = new Texture2D(textureResolution, 1, TextureFormat.RGBA32, false);;
mat.SetFloat("boundsY", boundsY);
mat.SetTexture("ramp", tex);
mat.SetVector("params", Vector3.zero);
}
//update fog
if (ShowFog)
{
if (playerController == null)
{
playerController = GameObject.FindGameObjectWithTag("Player").GetComponent <BallControl>();
}
if (cam == null)
{
cam = FindObjectOfType <Camera>();
}
//enable and set the fog
RenderSettings.fog = true;
RenderSettings.fogColor = cam.backgroundColor;
RenderSettings.fogEndDistance = playerController.visionRadius * fogDstMultiplier * 4;
//turn up the directional light
directionalLight.intensity = 2.3f;
playerLight.intensity = 23.0f;
}
else
{
//disable the fog
RenderSettings.fog = false;
//turn down the directional light
directionalLight.intensity = 1.0f;
playerLight.intensity = 3.0f;
}
}
void placeBuilding(TerrainGeneration TG, Vector3 cityCentre, float cityRadius)
{
Vector3 point = Random.insideUnitSphere * cityRadius;
point += cityCentre;
point.y = TG.terrain.SampleHeight(point);
//Instantiate(city,point,Quaternion.identity);
}
// Start is called before the first frame update
void Start()
{
buildingAttributes = GetComponent <BuildingAttributes>();
terrainGeneration = TerrainGeneration.instance;
gameManager = GameManager.instance;
x = (int)(transform.position.x + 0.5);
y = (int)(transform.position.z + 0.5);
}
void Awake()
{
if (instance != null)
{
Debug.LogError("More than one TerrainGeneration Script!");
return;
}
instance = this;
}
void Start()
{
terrainGeneration = gameObject.GetComponent <TerrainGeneration>();
meshFilter = gameObject.GetComponent <MeshFilter>();
//meshFilter.mesh = terrainGeneration.World.LoadWorldMesh();
Mesh mesh = terrainGeneration.World.OneRoomTest();
mesh.RecalculateNormals();
meshFilter.mesh = mesh;
}
private void Awake()
{
if (!instance) instance = this;
Seed = /*-6394955; */UnityEngine.Random.Range(-9999, 9999); // Generate the random seed
ChunkScale = new Vector3(ChunkSize / 10, 1, ChunkSize / 10); // Generate the chunk scale for the chunk object x,z size.
GenerateLodLevels();
CreatePool();
if (IsMultiThreaded) Instantiate(ThreadManager);
GenerateChunks(_updatedPosition);
GenerateAllChunkNeighbours();
}
public void OnGUI()
{
MountainFreq = EditorGUILayout.Slider("Mountain Frequency", MountainFreq, 0, 100);
Roughness = EditorGUILayout.Slider("Roughness", Roughness, 0, 5);
HeightMultiplier = EditorGUILayout.Slider("Height multiplier", HeightMultiplier, 0, 3);
BumpbMultiplier = EditorGUILayout.Slider("Bump multiplier", BumpbMultiplier, 0, 3);
BumpRoughness = EditorGUILayout.Slider("Bump roughness", BumpRoughness, 0, 2);
randomSeed = EditorGUILayout.Toggle("Use random seed", randomSeed);
if (!randomSeed)
{
EditorGUILayout.HelpBox("abc123", MessageType.Info);
seed = EditorGUILayout.TextField("Seed", seed);
}
useWater = EditorGUILayout.Toggle("Use water", useWater);
if (useWater)
{
if (GameObject.Find("Water"))
{
GameObject water = GameObject.Find("Water");
water.transform.position = new Vector3(water.transform.position.x, WaterLevel, water.transform.position.z);
WaterLevel = EditorGUILayout.FloatField("Waterlevel", WaterLevel);
}
else
{
EditorGUILayout.HelpBox("No water found!\n Name your water GameObject as 'Water'", MessageType.Error);
}
}
if(GUILayout.Button("Generate")){
TerrainGeneration TG = new TerrainGeneration();
TG.SetMountainFreq = MountainFreq;
TG.SetWaterlevel = WaterLevel;
TG.BumpMultiplier = BumpbMultiplier;
TG.BumbRoughness = BumpRoughness;
TG.HeightMultiplier = HeightMultiplier;
TG.Roughness = Roughness;
TG.terrain = Terrain.activeTerrain;
if (useWater && GameObject.Find("Water")) { TG.waterplane = GameObject.Find("Water"); TerrainFoliage.waterLevel = WaterLevel; }
TG.editor = true;
if (randomSeed)
{
TG.TerrainSeed = "" + (int)UnityEngine.Random.Range(0, int.MaxValue);
seed = TG.TerrainSeed;
} else
TG.TerrainSeed = seed;
Debug.Log("Using seed: " + TG.TerrainSeed);
TG.makeHeightmap();
}
Terrain.activeTerrain.heightmapPixelError = EditorGUILayout.Slider("Pixel error", Terrain.activeTerrain.heightmapPixelError, 1, 200);
Terrain.activeTerrain.basemapDistance = EditorGUILayout.Slider("Basemap distance", Terrain.activeTerrain.basemapDistance, 0, 2000);
}
// Use this for initialization
private void Start()
{
_generation = (TerrainGeneration) FindObjectOfType(typeof (TerrainGeneration));
_character = GetComponent<CharacterController>();
_waypoint = new Transform[_generation.pathOrder.Count];
foreach (var tile in _generation.pathOrder)
{
_waypoint[_generation.pathOrder.IndexOf(tile)] = new GameObject().transform;
_waypoint[_generation.pathOrder.IndexOf(tile)].position = new Vector3(tile.x * _generation.tileOffset, 0, tile.y * _generation.tileOffset);
}
}
void Awake()
{
// Register the singleton
if (Instance != null)
{
Debug.LogError("Multiple instances of BeatsEngine!");
}
Instance = this;
audioSource = GetComponent <AudioSource>();
sunScript = sun.GetComponent <SunScript>();
terrainGeneration = GetComponent <TerrainGeneration>();
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
TerrainGeneration generation = (TerrainGeneration)target;
if (GUILayout.Button("ReGenerate All Chunk Meshes"))
{
foreach(TerrainChunk chunk in TerrainGeneration.Chunks.Values)
{
chunk.GenerateChunkMesh();
}
}
}
public void GenerateTerrain(int xDir, int yDir)
{//Will handle all procedures that involve the board manager
GameObject[] enemyPosition2 = GameObject.FindGameObjectsWithTag("Enemy") as GameObject[];
if (xDir != 0)
{
int y;
int x = generationSize * xDir;
int xpos = (int)transform.position.x;
int ypos = (int)transform.position.y;
for (y = -generationSize; y <= generationSize; y++)
{
TerrainGeneration toQueue = new TerrainGeneration(xpos + x, ypos + y, 1);
generationQueue.Enqueue(toQueue);
toQueue = new TerrainGeneration(xpos - x, ypos + y, 0);
generationQueue.Enqueue(toQueue);
}
y = UnityEngine.Random.Range(-generationSize + 1, generationSize);
if (enemyPosition2.Length < 10)//If there are less than 10 enemies, then generate some more - keeps enemy spawning from going out of control
{
TerrainGeneration toQueue = new TerrainGeneration(x + (int)transform.position.x, y + (int)transform.position.y, 2);
generationQueue.Enqueue(toQueue);
}
}
else//Same thing except for the y direction
{
int x;
int y = generationSize * yDir;
int xpos = (int)transform.position.x;
int ypos = (int)transform.position.y;
for (x = -generationSize; x <= generationSize; x++)
{
TerrainGeneration toQueue = new TerrainGeneration(xpos + x, ypos + y, 1);
generationQueue.Enqueue(toQueue);
toQueue = new TerrainGeneration(xpos + x, ypos - y, 0);
generationQueue.Enqueue(toQueue);
}
x = UnityEngine.Random.Range(-generationSize + 1, generationSize);
if (enemyPosition2.Length < 10)//If there are less than 10 enemies, then generate some more - keeps enemy spawning from going out of control
{
TerrainGeneration toQueue = new TerrainGeneration(x + (int)transform.position.x, y + (int)transform.position.y, 2);
generationQueue.Enqueue(toQueue);
}
}
}
void InitializeTerrain()
{
// Generate the terrain mesh
Mesh mesh = TerrainGeneration.GenerateTerrainMesh(terrainWidth, resolution, terrainValues);
// Add a Mesh Renderer and Filter to the terrain game object, and apply the mesh to the filter
terrainGameObject.AddComponent <MeshRenderer>();
MeshFilter filter = terrainGameObject.AddComponent <MeshFilter>();
filter.mesh = mesh;
// Add EdgeCollider2D
//EdgeCollider2D edgeCollider = terrainGameObject.AddComponent<EdgeCollider2D>();
//edgeCollider.points = TerrainGeneration.CreateColliderPoints(mesh);
}
public void init()
{
int[,] chunkTileIDs;
int[,] backgroundTileIDs;
// get the chunk data from the terrain generator class and set the tilemap to it
chunkTileIDs = TerrainGeneration.generateChunkTiles(chunkX, chunkY, seed, biomeRefrence.biome, out backgroundTileIDs);
setTileToIdArray(chunkTileIDs);
// create the chunk background object
createChunkBackground();
// set the backgrounds tiles correctly based on our tile id
chunkBackground.setTileToIdArray(backgroundTileIDs);
}
void findCity(TerrainGeneration TG)
{
Vector2 point = Random.insideUnitCircle * (dimensions.x * 0.15f);
Vector3 start = new Vector3(point.x, 0.0f, point.y);
start += dimensions * 0.15f;
start.y = TG.terrain.SampleHeight(start);
/*for(int i=0;i<5;i++){
* placeBuilding(TG,start,50.0f);
* }*/
Transform t = Instantiate(city, start, Quaternion.identity) as Transform;
t.localScale = new Vector3(25.0f, 0.0f, 25.0f);
}
public void PrepareTerrainCell(TerrainGeneration tg)
{
this.tg = tg;
if (transform.position.z >= 30f)
{
resolution = tg.resolution * 4f;
}
else
{
resolution = tg.resolution;
}
PrepareMesh();
CalculateMesh();
SpawnButterfly();
}
//find a reasonable point on mesh to spawn an object
Vector3 FindPointOnMesh()
{
//get a new location coord across x and z axis
float visRad = GameObject.FindGameObjectWithTag("Player").GetComponent <BallControl>().visionRadius;
Vector3 playerPos = GameObject.FindGameObjectWithTag("Player").transform.position;
//get random direction
Vector3 NewLocation = Random.insideUnitSphere * visRad;
//zero out the vertical
NewLocation = new Vector3(NewLocation.x, 0.0f, NewLocation.z);
NewLocation += playerPos;
//find the chunk that is in
TerrainGeneration tG = FindObjectOfType <TerrainGeneration>();
Vector3Int coord = Vector3Int.RoundToInt(NewLocation / tG.ChunkSize);
//find the chunk if it already exists
GameObject chunk = GameObject.Find($"Chunk ({coord.x}, {coord.y}, {coord.z})");
//chunks mesh
Mesh mesh;
Chunk NewChunk = null;
//if no chunk exists at that coord, create it for this purpose
if (chunk == null)
{
NewChunk = tG.CreateChunkObject(coord);
NewChunk.SetUp(false, tG.material);
mesh = NewChunk.GetComponent <Chunk>().mesh;
tG.UpdateTerrainGPU(NewChunk);
}
else
{
mesh = chunk.GetComponent <Chunk>().mesh;
}
Vector3 MarkerLocation = FindClosestVertex(mesh, NewLocation);
//remove chunk if one was made to find mesh position
if (chunk == null)
{
NewChunk.Destroy();
}
return(MarkerLocation);
}
public void PrepareMesh(float height, float trunkThickness, int roots, float rootLength, TerrainGeneration tg)
{
this.height = height;
this.trunkThickness = trunkThickness;
this.roots = roots;
this.rootLength = rootLength;
this.tg = tg;
wood = tg.treeWoodMaterial;
leaves = new Material(tg.treeLeafMaterial);
leaves.color = new Color(Random.Range(0.3f, 0.8f), Random.Range(0.5f, 1.0f), Random.Range(0.2f, 0.4f), leaves.color.a);
meshRenderer = gameObject.AddComponent <MeshRenderer>();
meshRenderer.sharedMaterial = wood;
meshFilter = gameObject.AddComponent <MeshFilter>();
}
// Start is called before the first frame update
void Awake()
{
gm = GameObject.FindGameObjectWithTag("GameController").GetComponent <GameManager>();
CurrentBpm = bpm;
path = GetComponent <Path>();
terrainGeneration = GetComponent <TerrainGeneration>();
musicStructure = new NoteIndex[levelDuration + startOffset * 2];
ResetNotes(musicStructure);
bassSeed = Random.Range(0, 100f);
CreateDrumSequence();
CreateKickSequence();
CreateBassSequence();
CreateRoadPattern();
//path.GenerateStartPoints(stepDistance,2);
}
/*
* Get the position of the camera and then generate terrains around the camera
* TODO : Move Generate Trees to TerrainGeneration script
* TODO : Make water plane height adjustable
*/
public void UpdateMap()
{
var tileSize = tilePrefab.GetComponent <Terrain>().terrainData.size;
int tileWidth = (int)tileSize.x;
int tileDepth = (int)tileSize.z;
var currentCameraPosition = camera.transform.position;
var x = Mathf.Floor(currentCameraPosition.x / tileWidth) * tileWidth;
var z = Mathf.Floor(currentCameraPosition.z / tileDepth) * tileDepth;
int minMax = (int)Mathf.Floor(mapWidthInTiles / 2);
for (int zIndex = -minMax; zIndex <= minMax; zIndex++)
{
for (int xIndex = -minMax; xIndex <= minMax; xIndex++)
{
var tilePosition = new Vector3(x + xIndex * tileWidth, 0, z + zIndex * tileDepth);
int tilePositionIndexX = (int)(tilePosition.x / tileSize.x);
int tilePositionIndexZ = (int)(tilePosition.z / tileSize.z);
if (tilePosition.x >= 0 && tilePosition.z >= 0 && terrains[tilePositionIndexZ, tilePositionIndexX] == null)
{
var tile = Instantiate(Resources.Load("TerrainAssets/TerrainChunk") as GameObject, tilePosition, Quaternion.identity);
tile.transform.parent = world.transform;
var terrainTile = tile.GetComponent <TerrainGeneration>().GenerateTile();
var terrain = terrainTile.terrain;
terrains[tilePositionIndexZ, tilePositionIndexX] = terrain;
TerrainGeneration.Fix(terrain, terrains[tilePositionIndexZ, tilePositionIndexX - 1], terrains[tilePositionIndexZ - 1, tilePositionIndexX]);
// Create water plane, move and scale it at the center of the terrain
var waterTilePosition = new Vector3(tilePosition.x + (tileSize.x / 2), 39f, tilePosition.z + (tileSize.z / 2));
var waterTile = Instantiate(Resources.Load("TerrainAssets/WaterBasicDaytime") as GameObject, waterTilePosition, Quaternion.identity);
waterTile.transform.localScale = new Vector3(13, 1, 13);
waterTile.transform.parent = terrain.transform;
objectGeneration.GenerateTrees(terrainTile);
objectGeneration.GenerateGrass(terrainTile);
objectGeneration.GenerateRocks(terrainTile);
creatureGeneration.GenerationCreatures(terrainTile);
}
// Set currentTile to be where camera new position is
currentTile = new Bounds(new Vector3(x + (tileWidth / 2), 0, z + (tileDepth / 2)), new Vector3(tileWidth, 1000, tileDepth));
}
}
}
IEnumerator InitialisationCoroutine()
{
moveSpeed = 0.15f;
//Random.InitState(randomSeed); uncomment to seed simulation
mf = gameObject.AddComponent <MeshFilter>();
mr = gameObject.AddComponent <MeshRenderer>();
sliderProgress += 0.2f;
yield return(null);
testCrust = new Crust(meshWidth, meshHeight, triSize, seaLevel: 1.0f);
sliderProgress += 0.2f;
yield return(null);
testCrust.Mesh = MeshBuilder.BuildMesh(mf, mr, meshWidth, meshHeight, triSize);
testCrust = TerrainGeneration.ApplyFractalToCrust(testCrust);
Debug.Log("in apply: " + testCrust.CrustNodes[30, 222][0].Height);
sliderProgress += 0.2f;
yield return(null);
testCrust = PlateGeneration.SplitCrustIntoPlates(testCrust, meshWidth, meshHeight, plateCount, voronoiRelaxationSteps);
sliderProgress += 0.2f;
yield return(null);
for (int i = 0; i < testCrust.Plates.Length; i++)
{
while ((testCrust.Plates[i].XSpeed <0.3f && testCrust.Plates[i].XSpeed> -0.3f) && (testCrust.Plates[i].ZSpeed <0.3f && testCrust.Plates[i].ZSpeed> -0.3f))
{
testCrust.Plates[i].AccurateXSpeed = Random.Range(-2f, 2f);
testCrust.Plates[i].AccurateZSpeed = Random.Range(-2f, 2f);
}
sliderProgress += (0.2f / testCrust.Plates.Length);
yield return(null);
}
sliderBar.gameObject.SetActive(false);
}
public void generate()
{
generateWater();
TerrainGeneration TG = new TerrainGeneration();
TerrainGeneration.current = TG;
TerrainData tData = new TerrainData();
tData.size = dimensions;
Terrain.CreateTerrainGameObject(tData);
TG.SetMountainFreq = MountainFreq;
TG.SetWaterlevel = WaterLevel;
TG.BumpMultiplier = BumpMultiplier;
TG.BumpRoughness = BumpRoughness;
TG.HeightMultiplier = HeightMultiplier;
TG.Roughness = Roughness;
TG.terrain = Terrain.activeTerrain;
TG.waterplane = GameObject.Find("Water");
TG.ClipEdges = ClipEdges;
TerrainFoliage.waterLevel = WaterLevel;
TG.editor = true;
if (randomSeed)
{
TG.TerrainSeed = "" + (int)UnityEngine.Random.Range(0, int.MaxValue);
seed = TG.TerrainSeed;
}
else
{
TG.TerrainSeed = seed;
}
TG.makeHeightmap();
generateTextures();
generatePerson(TG);
generateSun2();
findCity(TG);
TerrainFoliage.grass = grass;
TerrainFoliage.grass2 = grass;
TerrainFoliage.BigTree = BigTree;
TerrainFoliage.Tree = Tree;
TerrainFoliage.GenerateFoliage(dimensions.x);
TerrainFoliage.GenerateGrass();
}
public void GenerateMap()
{
float[,] noiseMap = Noise.GenerateNoise(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset);
Color[] colorMap = new Color[mapWidth * mapHeight];
for (int x = 0; x < mapWidth; x++)
{
for (int y = 0; y < mapHeight; y++)
{
float currentHeight = noiseMap[x, y];
for (int i = 0; i < regions.Length; i++)
{
if (currentHeight <= regions[i].height)
{
colorMap[y * mapWidth + x] = regions[i].color;
break;
}
}
}
}
TerrainDisplay display = FindObjectOfType <TerrainDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
}
else if (drawMode == DrawMode.ColorMap)
{
display.DrawTexture(GenerateTexture(colorMap));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateMesh(noiseMap, meshHeightMultiplier, meshHeightCurve), GenerateTexture(colorMap));
}
else if (drawMode == DrawMode.Terrain)
{
display.DrawTerrain(TerrainGeneration.GenerateTerrain(terrainData, noiseMap), regions);
}
}
//Implemented using particle deposition
private void EruptVolcanos(List <Volcano> volcanos, int maxAge, int maxSearchRange, int maxElevationThreshold, int dropZoneRadius, float rockSize, float heightSimilarityEpsilon, bool updateCoords = false)
{
for (int v = 0; v < volcanos.Count; v++)
{
var vol = volcanos[v];
//Increase age
vol.Age++;
//If it's at the end of it's lifetime, remove it from the list and return it to the volcano object pool
if (vol.Age >= maxAge)
{
ObjectPooler.current.ReturnVolcanoToPool(vol);
volcanos.RemoveAt(v);
}
else //otherwise, do eruption (particle deposition)
{
crustNodes = TerrainGeneration.ParticleDeposition(crustNodes, vol, rockSize, heightSimilarityEpsilon, dropZoneRadius, maxSearchRange, maxElevationThreshold);
}
if (updateCoords)
{
if (crustNodes[vol.X, vol.Z][0].Plate.CheckMoveX())
{
vol.X = (vol.X + crustNodes[vol.X, vol.Z][0].Plate.XSpeed) % width;
if (vol.X < 0)
{
vol.X = width + vol.X;
}
}
if (crustNodes[vol.X, vol.Z][0].Plate.CheckMoveZ())
{
vol.Z = (vol.Z + crustNodes[vol.X, vol.Z][0].Plate.ZSpeed) % height;
if (vol.Z < 0)
{
vol.Z = height + vol.Z;
}
}
}
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
TerrainGeneration terrain = (TerrainGeneration)target;
if (GUILayout.Button("Generate"))
{
terrain.ClearTerrain();
terrain.GenerateTerrain();
// Sets Terrain Chunks to be navigation static
for (int i = 0; i < terrain.transform.childCount; ++i)
{
GameObjectUtility.SetStaticEditorFlags(terrain.transform.GetChild(i).gameObject, StaticEditorFlags.NavigationStatic);
}
}
if (GUILayout.Button("Clear"))
{
terrain.ClearTerrain();
}
}
public static Color[] GenerateHeightmapTexture(TerrainGeneration terrainGeneration, DebugPlaneType planeContent)
{
Color[] terrainTexture = new Color[terrainGeneration.TerrainInfo.TerrainWidth * terrainGeneration.TerrainInfo.TerrainHeight];
for (int y = 0; y < terrainGeneration.TerrainInfo.TerrainHeight; y++)
{
for (int x = 0; x < terrainGeneration.TerrainInfo.TerrainWidth; x++)
{
if (planeContent == DebugPlaneType.kAll)
{
if (terrainGeneration.TerrainInfo.TerrainTextureType == TextureType.kColored)
{
terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = terrainGeneration.TerrainInfo.TerrainParameterList[BiomeGeneration.GetCorrectBiomeIndex(terrainGeneration.TerrainInfo, x, y)].TerrainColor;
}
else
{
var valsTogether = terrainGeneration.TerrainInfo.HeightMap[x, y] + terrainGeneration.TerrainInfo.TemperatureMap[x, y] + terrainGeneration.TerrainInfo.MoistureMap[x, y];
valsTogether = valsTogether / 3;
terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, valsTogether);
}
}
else if (terrainGeneration.TerrainInfo.TerrainTextureType == TextureType.kGrayscale)
{
if (planeContent == DebugPlaneType.kHeightMap)
{
terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, terrainGeneration.TerrainInfo.HeightMap[x, y]);
}
else if (planeContent == DebugPlaneType.kMoistureMap)
{
terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, terrainGeneration.TerrainInfo.MoistureMap[x, y]);
}
else if (planeContent == DebugPlaneType.kTemperatureMap)
{
terrainTexture[y * terrainGeneration.TerrainInfo.TerrainWidth + x] = Color.Lerp(Color.white, Color.black, terrainGeneration.TerrainInfo.TemperatureMap[x, y]);
}
}
}
}
return(terrainTexture);
}
public void CreateChunk(int x, int y, int z)
{
WorldPos worldPos = new WorldPos(x, y, z);
//Instantiate the chunk at the coordinates using the chunk prefab
GameObject newChunkObject = Instantiate(chunkPrefab, new Vector3(x, y, z), Quaternion.Euler(Vector3.zero)) as GameObject;
Chunk newChunk = newChunkObject.GetComponent <Chunk>();
newChunk.pos = worldPos;
newChunk.world = this;
//Add it to the chunks dictionary with the position as the key
chunks.Add(worldPos, newChunk);
//Generate the terrain
TerrainGeneration terrainGen = new TerrainGeneration();
newChunk = terrainGen.ChunkGen(newChunk);
newChunk.SetBlocksUnmodified();
Serialization.Load(newChunk);
}
