void CheckSelectedTile()
{
RaycastHit hit;
TerrainController terrain = TerrainController.thisTerrainController;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, float.MaxValue, terrainLayer))
{
highlighter.Clear();
GridTile tile = GridTile.FindClosestGridTile(hit.point - new Vector3(terrain.tileSize / 2, 0, terrain.tileSize / 2));
if (tile == null)
{
return;
}
for (int i = 0; i < 4; i++)
{
vert[i] = tile.gridNodes[i].position + new Vector3(0, 0.3f, 0);
}
highlighter.vertices = vert;
highlighter.triangles = tri;
highlighter.uv = uv;
UIScript.GetInstance().SetActiveTile(tile);
}
highlighter.RecalculateNormals();
GetComponent <MeshFilter>().mesh = highlighter;
}
void UpdateSelectionMesh()
{
int tileSize = terrainController.tileSize;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Mathf.Infinity, mask))
{
vertices.Clear();
triangles.Clear();
Vector3 hitPoint = hit.point;
for (int i = -currentSize; i < currentSize; i++)
{
for (int j = -currentSize; j < currentSize; j++)
{
Vector3 currentPos = new Vector3(hitPoint.x + i * tileSize, 0, hitPoint.z + j * tileSize);
GridTile curGridTile = GridTile.FindClosestGridTile(currentPos);
if (curGridTile == null || Vector3.Distance(hit.point, curGridTile.position) > currentSize * tileSize)
{
continue;
}
CreatePlane(curGridTile.gridNodes.ToArray());
}
}
SetMesh();
}
}
bool AboveGround(Vector3 vertex)
{
if (GridTile.FindClosestGridTile(vertex + transform.position) != null)
{
return(vertex.y > GridTile.FindClosestGridTile(vertex + transform.position).position.y);
}
else
{
return(false);
}
}
// Use this for initialization
void Start()
{
city = this;
terrain = TerrainController.thisTerrainController;
float xPos = minLocX * terrain.length + (float)rand.NextDouble() * (maxLocX - minLocX) * terrain.length;
float zPos = minLocZ * terrain.width + (float)rand.NextDouble() * (maxLocZ - minLocZ) * terrain.width;
Vector3 centerPos = new Vector3(xPos, 0, zPos);
centerTile = GridTile.FindClosestGridTile(centerPos);
cityPointTimer = 0;
cityPoints = 0;
requiredCityPoints = 8000;
maximumRadius = 400;
currentRadius = startRadius;
StartCoroutine(BuildStartCity());
}
// Set the terrain height around a position to the tile closest to the entered position
void EqualTerrain(Vector3 pos, float circleRadius, bool isTemp)
{
GridTile middleTile = GridTile.FindClosestGridTile(pos);
List <GridTile> gridtiles = GridTile.FindGridTilesAround(pos, circleRadius);
List <Chunk> updateChunks = new List <Chunk>();
foreach (GridTile tile in gridtiles)
{
for (int i = 0; i < tile.gridNodes.Count; i++)
{
if (tile.gridNodes[i].heighIsSet)
{
continue;
}
Vector3 newPos = Vector3.zero;
Vector3 vertex = tile.gridNodes[i].position;
Chunk[] chunks = Chunk.FindChunksWithVertex(vertex);
foreach (Chunk chunk in chunks)
{
int[] index = Chunk.FindClosestVertices(vertex, chunk);
float diffx = chunk.gameObject.transform.position.x + chunk.map[index[0], index[1]].x - middleTile.position.x;
float diffz = chunk.gameObject.transform.position.z + chunk.map[index[0], index[1]].z - middleTile.position.z;
newPos = new Vector3(chunk.map[index[0], index[1]].x, pos.y, chunk.map[index[0], index[1]].z);
if (!isTemp)
{
chunk.map[index[0], index[1]] = newPos;
}
else
{
chunk.tempMap[index[0], index[1]] = newPos;
}
//chunk.AddVertsAndUVAndNorm(chunk.map.GetLength(0), true);
if (!updateChunks.Contains(chunk))
{
updateChunks.Add(chunk);
}
}
if (!isTemp)
{
tile.gridNodes[i].position = new Vector3(tile.gridNodes[i].position.x, pos.y, tile.gridNodes[i].position.z);
tile.gridNodes[i].heighIsSet = true;
}
}
if (!isTemp)
{
tile.position = tile.gridNodes[0].position;
}
}
foreach (Chunk chunk in updateChunks)
{
chunk.GenerateTerrainMesh(true, isTemp);
tempChunks.Add(chunk);
}
}
// Function that determines if a tile has an object on it and return true if there is no objects on all the tiles in a circle with size as diameter.
public bool CanBuild(Vector3 pos, float size, GameObject buildObj, float scale, Quaternion rotation, bool neglectTerrainObjects)
{
List <GridTile> gridtiles = GridTile.FindGridTilesAround(pos, size + 60);
GridTile thisTile = GridTile.FindClosestGridTile(pos);
Collider[] colliders = Physics.OverlapBox(buildObj.GetComponent <BoxCollider>().center *scale + pos, buildObj.GetComponent <BoxCollider>().size / 2 * scale, rotation, notTerrain);
if (colliders.Length > 1)
{
return(false);
}
else if (colliders.Length == 1 && colliders[0].gameObject.GetInstanceID() != buildObj.gameObject.GetInstanceID())
{
return(false);
}
if (pos.y <= TerrainController.thisTerrainController.waterLevel)
{
return(false);
}
float lowPoint = pos.y;
float highPoint = pos.y;
bool heighSet = false;
foreach (GridTile tile in gridtiles)
{
if (tile.isOutsideBorder)
{
return(false);
}
for (int i = 0; i < tile.gridNodes.Count; i++)
{
if (tile.gridNodes[i].position.y > highPoint)
{
highPoint = tile.position.y;
}
else if (tile.gridNodes[i].position.y < lowPoint)
{
lowPoint = tile.position.y;
}
if (tile.gridNodes[i].heighIsSet)
{
heighSet = true;
}
}
}
if ((highPoint - lowPoint > 40 || lowPoint < TerrainController.thisTerrainController.waterLevel) && heighSet)
{
return(false);
}
if (BuildingHeight(pos, size * scale) == -1)
{
return(false);
}
return(true);
}
void CalculateChunk(object args)
{
object[] argsArr = (object[])args;
int i = (int)argsArr[0];
float time = (float)argsArr[1];
int operationsPerThread = Mathf.CeilToInt(windSpeedChunks.Count / chunkThreads.Length);
int windCount = windSpeedChunks.Count;
int startK = (int)i * operationsPerThread;
int endK = ((int)i + 1) * operationsPerThread;
for (int k = startK; k < endK; k++)
{
if (k >= windCount)
{
break;
}
if (!windSpeedChunks[k].isEnabled)
{
continue;
}
List <Vector3> vert = threadVerts[k];
for (int j = 0; j < vert.Count; j++)
{
GridTile tile = GridTile.FindClosestGridTile(vert[j]);
if (tile != null && tile.canSeeWind && !tile.isOutsideBorder)
{
float curWind = WindController.GetWindAtTile(tile, height, time);
Vector2 curUv = new Vector2(1 - curWind / WindController.WindMagnitudeAtTime(time), 1 - curWind / WindController.WindMagnitudeAtTime(time));
for (int intp = 0; intp < intpSteps; intp++)
{
if (curUvs)
{
Vector2 interpolated = Vector2.Lerp(buffereduvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1));
uvs[k][intp][j].Set(interpolated.x, interpolated.y);
}
else
{
Vector2 interpolated = Vector2.Lerp(uvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1));
buffereduvs[k][intp][j].Set(interpolated.x, interpolated.y);
}
if (stopThreads)
{
return;
}
}
}
else if (tile != null && !tile.canSeeWind && !tile.isOutsideBorder)
{
Vector2 curUv = new Vector2(0.125f, 0.875f);
for (int intp = 0; intp < intpSteps; intp++)
{
if (curUvs)
{
Vector2 interpolated = Vector2.Lerp(buffereduvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1));
uvs[k][intp][j].Set(interpolated.x, interpolated.y);
}
else
{
Vector2 interpolated = Vector2.Lerp(uvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1));
buffereduvs[k][intp][j].Set(interpolated.x, interpolated.y);
}
if (stopThreads)
{
return;
}
}
}
}
}
}
void Start()
{
uniProperties = GetComponent <UniversalProperties>();
health = 1;
onGridtile = GridTile.FindClosestGridTile(transform.position);
}
