void SetClimateData(int cellIndex, float moisture, float clouds)
{
TriDirection d = TriDirection.VERT;
TriCell current, k;
ClimateData t;
current = k = grid.GetCell(cellIndex);
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
t = new ClimateData();
t.moisture = moisture;
t.clouds = clouds;
climate[k.Index] = t;
k = k.GetNeighbor(d);
if (current.inverted)
{
d = d.Next();
}
else
{
d = d.Previous();
}
}
}
public void StartCalculateTerrain()
{
terrainSelectionViewer.Clear();
switch (terrainType)
{
case SizeType.HEX:
TriCell k = selectedCell;
int elev = selectedCell.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
RecalculateTerrain(k);
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
case SizeType.SINGLE:
RecalculateTerrain(selectedCell);
break;
}
terrainSelectionViewer.Apply();
}
public Building CreateBuilding(TriDirection dir, TriCell cell, Building prefab)
{
List <BuildState> result = prefab.GetBuildStatus(cell.coordinates, dir);
bool buildable = true;
foreach (BuildState i in result)
{
if (!i.value)
{
buildable = false;
}
}
if (cell && buildable)
{
Building ret = Instantiate(prefab);
ret.ID = entities.BuildingCount;
ret.Location = cell;
switch (ret.sizeType)
{
case SizeType.SINGLE:
cell.Statics = ret;
break;
case SizeType.HEX:
TriCell k = cell;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
k.Statics = ret;
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
}
ret.EntranceDirection = dir;
ret.personList = personList;
entities.AddBuilding(ret);
island.ShowSummary = island.ShowSummary;
Debug.Log(ret + " built");
return(ret);
}
else
{
Debug.Log("building failed");
return(null);
}
}
public override List <BuildState> GetBuildStatus(TriCoordinates coord, TriDirection dir)
{
List <BuildState> ret = new List <BuildState>();
TriCell cell = TriGrid.Instance.GetCell(coord);
int elev = cell.Elevation;
ret.Add(new BuildState(coord, cell.HasRiver));
TriCell entrance = cell.GetNeighbor(dir);
ret.Add(new BuildState(entrance.coordinates, entrance.IsBuildable() && Mathf.Abs(elev - entrance.Elevation) < 2));
cell = cell.GetNeighbor(dir.Previous());
ret.Add(new BuildState(cell.coordinates, cell.HasRiver && Mathf.Abs(elev - cell.Elevation) < 2));
cell = cell.GetNeighbor(dir);
ret.Add(new BuildState(cell.coordinates, cell.IsBuildable() && Mathf.Abs(elev - cell.Elevation) < 2));
return(ret);
}
bool IsBuildable()
{
if (nowCell)
{
if (!nowCell.GetNeighbor(dir).IsBuildable())
{
return(false);
}
if (sizeType != null)
{
switch (sizeType)
{
case SizeType.HEX:
TriCell k = nowCell;
int elev = nowCell.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k || !k.IsBuildable())
{
return(false);
}
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
return(true);
case SizeType.SINGLE:
return(nowCell.IsBuildable());
default:
return(false);
}
}
return(true);
}
else
{
return(false);
}
}
public Building CreateBuilding(TriDirection dir, TriCell cell, Building prefab)
{
if (cell && Entity.IsBuildable(dir, cell.coordinates, prefab.sizeType))
{
Building ret = Instantiate(prefab);
ret.ID = entities.BuildingCount;
ret.Location = cell;
switch (ret.sizeType)
{
case SizeType.SINGLE:
cell.Statics = ret;
break;
case SizeType.HEX:
TriCell k = cell;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
k.Statics = ret;
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
break;
}
ret.EntranceDirection = dir;
ret.personList = personList;
entities.AddBuilding(ret);
Debug.Log("camp built");
return(ret);
}
else
{
Debug.Log("building failed");
return(null);
}
}
public static bool IsBuildable(TriDirection dir, TriCoordinates coord, SizeType sizeType)
{
switch (sizeType)
{
case SizeType.SINGLE:
if (TriGrid.Instance.GetCell(coord).Statics)
{
return(false);
}
else
{
return(true);
}
case SizeType.HEX:
TriCell cell = TriGrid.Instance.GetCell(coord);
int elevation = cell.Elevation;
TriCell k = cell;
int elev = cell.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k || !k.IsBuildable())
{
return(false);
}
if (elev != k.Elevation)
{
return(false);
}
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
return(true);
default:
return(false);
}
}
public override List <BuildState> GetBuildStatus(TriCoordinates coord, TriDirection dir)
{
List <BuildState> ret = new List <BuildState>();
TriCell k = TriGrid.Instance.GetCell(coord);
int elev = k.Elevation;
TriDirection tDir = dir.Previous();
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
ret.Add(new BuildState(k.coordinates, k.IsBuildable() && elev == k.Elevation));
k = k.GetNeighbor(tDir);
tDir = tDir.Next();
}
TriCell entrance = TriGrid.Instance.GetCell(coord).GetNeighbor(dir);
ret.Add(new BuildState(entrance.coordinates, entrance.IsBuildable() && Mathf.Abs(entrance.GetNeighbor(dir).Elevation - elev) < 2));
return(ret);
}
void EditHex(TriCell cell)
{
TriCell k = cell;
bool inverted = cell.inverted;
TriDirection d = TriDirection.VERT;
for (int i = 0; i < 6; i++)
{
if (!k)
{
break;
}
EditCell(k);
k = k.GetNeighbor(d);
if (inverted)
{
d = d.Next();
}
else
{
d = d.Previous();
}
}
}
void TriangulateWithRiver(TriCell cell, TriDirection direction, Vector3 center, EdgeVertices edge, Color color)
{
Vector3 riverOffset = new Vector3(0, TriMetrics.streamBedElevationOffset - TriMetrics.waterElevationOffset, 0);
Vector3 nextCorner, prevCorner;
nextCorner = (center + edge.v1) / 2f;
prevCorner = (center + edge.v5) / 2f;
Vector3 underCenter = center, underNextCorner = nextCorner, underPrevCorner = prevCorner;
underCenter.y += TriMetrics.streamBedElevationOffset;
underNextCorner.y += TriMetrics.streamBedElevationOffset;
underPrevCorner.y += TriMetrics.streamBedElevationOffset;
EdgeVertices underEdge = edge;
underEdge.v1.y += TriMetrics.streamBedElevationOffset;
underEdge.v2.y += TriMetrics.streamBedElevationOffset;
underEdge.v3.y += TriMetrics.streamBedElevationOffset;
underEdge.v4.y += TriMetrics.streamBedElevationOffset;
underEdge.v5.y += TriMetrics.streamBedElevationOffset;
terrain.AddTriangle(nextCorner, edge.v1, edge.v2);
terrain.AddTriangle(prevCorner, edge.v4, edge.v5);
terrain.AddTriangle(underCenter, underEdge.v2, underEdge.v4);
terrain.AddTriangleColor(color);
terrain.AddTriangleColor(color);
terrain.AddTriangleColor(color);
if (!cell.IsUnderwater)
{
rivers.AddTriangle(underCenter - riverOffset, underEdge.v2 - riverOffset, underEdge.v4 - riverOffset);
rivers.AddTriangleColor(Color.blue);
}
if (cell.HasRiverThroughEdge(direction.Next()))
{
terrain.AddTriangle(underEdge.v4, underPrevCorner, underCenter);
terrain.AddTriangleColor(color);
if (!cell.IsUnderwater)
{
rivers.AddTriangle(underEdge.v4 - riverOffset, underPrevCorner - riverOffset, underCenter - riverOffset);
rivers.AddTriangleColor(Color.blue);
}
terrain.AddQuad(underPrevCorner, prevCorner, underEdge.v4, edge.v4);
terrain.AddQuadColor(color, color);
}
else
{
terrain.AddTriangle(center, edge.v4, prevCorner);
terrain.AddQuad(underCenter, center, underEdge.v4, edge.v4);
terrain.AddTriangleColor(color);
terrain.AddQuadColor(color, color);
}
if (cell.HasRiverThroughEdge(direction.Previous()))
{
terrain.AddTriangle(underEdge.v2, underCenter, underNextCorner);
terrain.AddTriangleColor(color);
if (!cell.IsUnderwater)
{
rivers.AddTriangle(underEdge.v2 - riverOffset, underCenter - riverOffset, underNextCorner - riverOffset);
rivers.AddTriangleColor(Color.blue);
}
terrain.AddQuad(underEdge.v2, edge.v2, underNextCorner, nextCorner);
terrain.AddQuadColor(color, color);
}
else
{
terrain.AddTriangle(center, nextCorner, edge.v2);
terrain.AddQuad(underEdge.v2, edge.v2, underCenter, center);
terrain.AddTriangleColor(color);
terrain.AddQuadColor(color, color);
}
}
public static TriDirection Next2(this TriDirection direction)
{
return(direction.Previous());
}
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);
}
