public Color GetColor()
{
if (IsUnderwater)
{
return(TriMetrics.FromARGB(255, 0, 0, 255));
}
if (Statics)
{
if (Statics is Natural)
{
return(Color.green);
}
else if (Statics is Building)
{
return(TriMetrics.FromARGB(255, 139, 69, 19));
}
else
{
return(TriMetrics.FromARGB(255, 255, 248, 220));
}
}
else
{
return(Color);
}
}
public void RecalculateTerrain(TriCell cell)
{
Vector3 nextCorner, prevCorner;
EdgeVertices edge;
for (TriDirection direction = TriDirection.VERT; direction <= TriDirection.RIGHT; direction++)
{
Vector3 center = cell.Position, v1, v2;
v1 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetFirstSolidCorner(direction);
v2 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetSecondSolidCorner(direction);
edge = new EdgeVertices(v1, v2);
nextCorner = (center + edge.v1) / 2f;
prevCorner = (center + edge.v5) / 2f;
terrainSelectionViewer.AddTriangle(nextCorner, edge.v1, edge.v2);
terrainSelectionViewer.AddTriangle(prevCorner, edge.v4, edge.v5);
terrainSelectionViewer.AddTriangle(center, edge.v2, edge.v4);
terrainSelectionViewer.AddTriangle(center, edge.v4, prevCorner);
terrainSelectionViewer.AddTriangle(center, nextCorner, edge.v2);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
terrainSelectionViewer.AddTriangleColor(Color.blue);
}
}
public void RecalculateTerrain(TriCell cell, bool buildable)
{
Vector3 nextCorner, prevCorner;
EdgeVertices edge;
for (TriDirection direction = TriDirection.VERT; direction <= TriDirection.RIGHT; direction++)
{
Vector3 center = cell.Position, v1, v2;
//entityMenu.transform.localPosition = center + new Vector3(0, 20, 0);
v1 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetFirstSolidCorner(direction);
v2 = center + (cell.inverted ? -1 : 1) * TriMetrics.GetSecondSolidCorner(direction);
edge = new EdgeVertices(v1, v2);
nextCorner = (center + edge.v1) / 2f;
prevCorner = (center + edge.v5) / 2f;
AddTriangle(nextCorner, edge.v1, edge.v2);
AddTriangle(prevCorner, edge.v4, edge.v5);
AddTriangle(center, edge.v2, edge.v4);
AddTriangle(center, edge.v4, prevCorner);
AddTriangle(center, nextCorner, edge.v2);
Color c = buildable ? Color.blue : Color.red;
AddTriangleColor(c);
AddTriangleColor(c);
AddTriangleColor(c);
AddTriangleColor(c);
AddTriangleColor(c);
}
}
public void AddTriangle(Vector3 v1, Vector3 v2, Vector3 v3)
{
int vertexIndex = vertices.Count;
vertices.Add(TriMetrics.Perturb(v1));
vertices.Add(TriMetrics.Perturb(v2));
vertices.Add(TriMetrics.Perturb(v3));
triangles.Add(vertexIndex++);
triangles.Add(vertexIndex++);
triangles.Add(vertexIndex);
}
public void AddQuad(Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4)
{
int vertexIndex = vertices.Count;
vertices.Add(TriMetrics.Perturb(v1));
vertices.Add(TriMetrics.Perturb(v2));
vertices.Add(TriMetrics.Perturb(v3));
vertices.Add(TriMetrics.Perturb(v4));
triangles.Add(vertexIndex);
triangles.Add(vertexIndex + 2);
triangles.Add(vertexIndex + 1);
triangles.Add(vertexIndex + 1);
triangles.Add(vertexIndex + 2);
triangles.Add(vertexIndex + 3);
}
void EvolveClimate(int cellIndex)
{
TriCell cell = grid.GetCell(cellIndex);
ClimateData cellClimate = climate[cellIndex];
float tMoisture = cellClimate.moisture, tClouds = cellClimate.clouds;
if (cell.IsUnderwater)
{
tMoisture = 1f;
tClouds += evaporationFactor;
}
else
{
float evaporation = tMoisture * evaporationFactor;
tMoisture -= evaporation;
tClouds += evaporation;
}
float precipitation = tClouds * precipitationFactor;
tClouds -= precipitation;
tMoisture += precipitation;
//SetClimateData(cellIndex, tMoisture, tClouds);
float cloudDispersal = tClouds * (1f / 6f);
float runoff = tMoisture * runoffFactor * (1f / 6f);
for (int i = 0; i < 4; i++)
{
TriCell neighbor = grid.GetCell(TriMetrics.TriToHex(cell.coordinates) + new Vector2Int(TriMetrics.hexDir[i, 0], TriMetrics.hexDir[i, 1]));
if (!neighbor)
{
continue;
}
ClimateData neighborClimate = climate[neighbor.Index];
float tNMoisture = neighborClimate.moisture, tNClouds = neighborClimate.clouds;
tNClouds += cloudDispersal;
int elevationDelta = neighbor.Elevation - cell.Elevation;
if (elevationDelta < 0)
{
tMoisture -= runoff;
tNMoisture += runoff;
}
SetClimateData(neighbor.Index, tNMoisture, tNClouds);
//climate[neighbor.Index] = neighborClimate;
}
tClouds = 0f;
SetClimateData(cellIndex, tMoisture, tClouds);
//climate[cellIndex] = cellClimate;
}
void Triangulate(TriDirection direction, TriCell cell)
{
int inverter = 0;
if (cell.inverted)
{
inverter = -1;
}
else
{
inverter = 1;
}
Vector3 center = cell.Position, v1, v2;
v1 = center + inverter * TriMetrics.GetFirstSolidCorner(direction);
v2 = center + inverter * TriMetrics.GetSecondSolidCorner(direction);
EdgeVertices e = new EdgeVertices(v1, v2);
if (cell.IsUnderwater)
{
TriangulateWater(center, e);
}
if (cell.HasRiverThroughEdge(direction))
{
TriangulateWithRiver(cell, direction, center, e, cell.Color);
}
else
{
TriangulateEdgeFan(center, e, cell.Color);
}
if (cell.inverted)
{
if (direction != TriDirection.LEFT)
{
TriangulateConnection(direction, cell, e, inverter);
}
}
else
{
if (direction == TriDirection.LEFT)
{
TriangulateConnection(direction, cell, e, inverter);
}
}
}
void TriangulateConnection(TriDirection direction, TriCell cell, EdgeVertices e1, int inverter)
{
Vector3 center = cell.transform.localPosition;
TriCell neighbor = cell.GetNeighbor(direction);
if (neighbor == null)
{
return;
}
Vector3 bridge = TriMetrics.GetBridge(direction);
bridge.y = neighbor.Position.y - cell.Position.y;
EdgeVertices e2 = new EdgeVertices(
e1.v1 + bridge,
e1.v5 + bridge
);
TriangulateEdgeStrip(terrain, e1, cell.Color, e2, neighbor.Color, cell.HasRiverThroughEdge(direction));
}
void CreateClimate()
{
climate.Clear();
ClimateData initialData = new ClimateData();
for (int i = 0; i < cellCount; i++)
{
climate.Add(initialData);
}
for (int cycle = 0; cycle < 40; cycle++)
{
for (int i = 0; i < cellCount; i++)
{
TriCoordinates t = grid.GetCell(i).coordinates;
if (t == TriMetrics.TriToHex(t))
{
EvolveClimate(i);
}
}
}
}
IEnumerator <WaitForEndOfFrame> CreateClimate()
{
climate.Clear();
ClimateData initialData = new ClimateData();
for (int i = 0; i < cellCount; i++)
{
climate.Add(initialData);
}
for (int cycle = 0; cycle < 40; cycle++)
{
for (int i = 0; i < cellCount; i++)
{
TriCoordinates t = grid.GetCell(i).coordinates;
if (t == TriMetrics.TriToHex(t))
{
EvolveClimate(i);
}
}
}
yield return(null);
}
TriCell GetRandomCell()
{
TriCoordinates t = TriMetrics.TriToHex(new TriCoordinates(Random.Range(xMin, xMax), Random.Range(zMin, zMax)));
return(grid.GetCell(t.X, t.Z));
}
IEnumerator <WaitForEndOfFrame> SetTerrainType()
{
for (int i = 0; i < cellCount; i++)
{
TriCell cell = grid.GetCell(i), hexCell = grid.GetCell(TriMetrics.TriToHex(cell.coordinates));
if (cell.coordinates == hexCell.coordinates)
{
float moisture = climate[hexCell.Index].moisture;
TriDirection d = TriDirection.VERT;
TriIsland isle = TriIsland.Instance;
for (int j = 0; j < 6; j++)
{
if (!cell)
{
break;
}
if (!cell.IsUnderwater)
{
if (cell.Elevation > 10)
{
cell.TerrainTypeIndex = 4;
}
else if (moisture < 0.02f)
{
cell.TerrainTypeIndex = 3;
if (Random.value < 0.5f && !cell.HasRiver)
{
Tree t = (Tree)Instantiate(TriIsland.GetNaturalPrefabs((int)NaturalType.TREE, 0), isle.transform);
t.Location = cell;
t.EntranceDirection = (TriDirection)((int)(Random.value * 3f));
entities.AddNatural(t);
}
}
else if (moisture < 0.12f)
{
cell.TerrainTypeIndex = 2;
if (Random.value < 0.2f && !cell.HasRiver)
{
Tree t = (Tree)Instantiate(TriIsland.GetNaturalPrefabs((int)NaturalType.TREE, 0), isle.transform);
t.Location = cell;
t.EntranceDirection = (TriDirection)((int)(Random.value * 3f));
entities.AddNatural(t);
}
}
else if (moisture < 0.20f)
{
cell.TerrainTypeIndex = 1;
}
else if (moisture < 0.85f)
{
cell.TerrainTypeIndex = 0;
}
else
{
cell.TerrainTypeIndex = 0;
}
}
else
{
cell.TerrainTypeIndex = 1;
}
cell = cell.GetNeighbor(d);
if (hexCell.inverted)
{
d = d.Next();
}
else
{
d = d.Previous();
}
}
if (i % Metrics.refreshLimit == 0)
{
yield return(null);
}
}
}
}
int RaiseTerrain(int chunkSize, int budget, bool initiated)
{
searchFrontierPhase += 1;
TriCoordinates center = grid.GetCell(grid.cellCountX / 2, grid.cellCountZ / 2).coordinates;
center = TriMetrics.TriToHex(center);
TriCell firstCell = grid.GetCell(center.X, center.Z);
if (initiated)
{
do
{
firstCell = GetRandomCell();
} while (firstCell.Elevation < 1);
}
searchFrontier.Enqueue(firstCell);
center = firstCell.coordinates;
checker.Add(center);
int size = 0;
while (size < chunkSize && searchFrontier.Count > 0)
{
TriCell current = searchFrontier.Dequeue();
if (current.Elevation < elevationMaximum)
{
TriDirection d = TriDirection.VERT;
TriCell k = current;
if (k.Elevation < elevationMaximum)
{
if (k.Elevation == 0)
{
budget -= 6;
}
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
k.Elevation += 1;
k = k.GetNeighbor(d);
if (current.inverted)
{
d = d.Next();
}
else
{
d = d.Previous();
}
}
}
}
if (current.Elevation == 1 && budget == 0)
{
break;
}
size += 6;
TriCoordinates coord = current.coordinates;
for (int i = 0; i < 4; i++)
{
TriCell neighbor = grid.GetCell(coord.X + TriMetrics.hexDir[i, 0], coord.Z + TriMetrics.hexDir[i, 1]);
if (neighbor && checkbounds(neighbor.coordinates) && !checker.Contains(neighbor.coordinates) && (i == 3 || Random.value < jitterProbability ? true : false))
{
searchFrontier.Enqueue(neighbor);
checker.Add(neighbor.coordinates);
}
}
}
searchFrontier.Clear();
checker.Clear();
return(budget);
}
