private void AddWallSegment(Vector3 pivot, HexCell pivotCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell)
{
if (pivotCell.IsUnderwater)
{
return;
}
bool hasLeftWall = !leftCell.IsUnderwater && pivotCell.GetEdgeType(leftCell) != HexEdgeType.Cliff;
bool hasRighWall = !rightCell.IsUnderwater && pivotCell.GetEdgeType(rightCell) != HexEdgeType.Cliff;
if (hasLeftWall)
{
if (hasRighWall)
{
bool hasTower = false;
if (leftCell.Elevation == rightCell.Elevation)
{
HexHash hash = HexMetrics.SampleHashGrid((pivot + left + right) * (1f / 3f));
hasTower = hash.e < HexMetrics.wallTowerThreshold;
}
AddWallSegment(pivot, left, pivot, right, hasTower);
}
else if (leftCell.Elevation < rightCell.Elevation)
{
AddWallWedge(pivot, left, right);
}
else
{
AddWallCap(pivot, left);
}
}
else if (hasRighWall)
{
if (rightCell.Elevation < leftCell.Elevation)
{
AddWallWedge(right, pivot, left);
}
else
{
AddWallCap(right, pivot);
}
}
}
void TriangulateConnection(HexDirection direction, HexCell cell, Vector3 v1, Vector3 v2)
{
HexCell neighbor = cell.GetNeighbor(direction);
if (neighbor == null)
{
return;
}
Vector3 bridge = HexMetrics.GetBridge(direction);
Vector3 v3 = v1 + bridge;
Vector3 v4 = v2 + bridge;
v3.y = v4.y = neighbor.Elevation * HexMetrics.ElevationStep;
if (cell.GetEdgeType(direction) == HexEdgeType.Slope)
{
TriangulateEdgeTerraces(v1, v2, cell, v3, v4, neighbor);
}
else
{
AddQuad(v1, v2, v3, v4);
AddQuadColor(cell.Color, neighbor.Color);
}
HexCell nextNeighbor = cell.GetNeighbor(direction.Next());
if (direction <= HexDirection.E && nextNeighbor != null)
{
Vector3 v5 = v2 + HexMetrics.GetBridge(direction.Next());
v5.y = nextNeighbor.Elevation * HexMetrics.ElevationStep;
if (cell.Elevation <= neighbor.Elevation)
{
if (cell.Elevation <= nextNeighbor.Elevation)
{
TriangulateCorner(v2, cell, v4, neighbor, v5, nextNeighbor);
}
else
{
TriangulateCorner(v5, nextNeighbor, v2, cell, v4, neighbor);
}
}
else if (neighbor.Elevation <= nextNeighbor.Elevation)
{
TriangulateCorner(v4, neighbor, v5, nextNeighbor, v2, cell);
}
else
{
TriangulateCorner(v5, nextNeighbor, v2, cell, v4, neighbor);
}
}
}
void TriangulateCorner(Vector3 bottom, HexCell bottomCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell)
{
HexEdgeType leftEdgeType = bottomCell.GetEdgeType(leftCell);
HexEdgeType rightEdgeType = bottomCell.GetEdgeType(rightCell);
if (leftEdgeType == HexEdgeType.Slope)
{
if (rightEdgeType == HexEdgeType.Slope)
{
TriangulateCornerTerraces(bottom, bottomCell, left, leftCell, right, rightCell);
}
else if (rightEdgeType == HexEdgeType.Flat)
{
TriangulateCornerTerraces(left, leftCell, right, rightCell, bottom, bottomCell);
}
else
{
TriangulateCornerTerracesCliff(bottom, bottomCell, left, leftCell, right, rightCell);
}
}
else if (rightEdgeType == HexEdgeType.Slope)
{
if (leftEdgeType == HexEdgeType.Flat)
{
TriangulateCornerTerraces(right, rightCell, bottom, bottomCell, left, leftCell);
}
else
{
TriangulateCornerCliffTerraces(bottom, bottomCell, left, leftCell, right, rightCell);
}
}
else if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope)
{
if (leftCell.Elevation < rightCell.Elevation)
{
TriangulateCornerCliffTerraces(right, rightCell, bottom, bottomCell, left, leftCell);
}
else
{
TriangulateCornerTerracesCliff(left, leftCell, right, rightCell, bottom, bottomCell);
}
}
else
{
AddTriangle(bottom, left, right);
AddTriangleColor(bottomCell.Color, leftCell.Color, rightCell.Color);
}
}
private void TriangulateCornerCliffTerraces(
Vector3 begin, HexCell beginCell,
Vector3 left, HexCell leftCell,
Vector3 right, HexCell rightCell
)
{
float b = 1f / (leftCell.Elevation - beginCell.Elevation);
if (b < 0)
{
b = -b;
}
Vector3 boundary = Vector3.Lerp(
HexMetrics.Perturb(begin), HexMetrics.Perturb(left), b
);
Color boundaryWeights = Color.Lerp(weights1, weights2, b);
Vector3 indices;
indices.x = beginCell.Index;
indices.y = leftCell.Index;
indices.z = rightCell.Index;
TriangulateBoundaryTriangle(
right, weights3, begin, weights1, boundary, boundaryWeights, indices
);
if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope)
{
TriangulateBoundaryTriangle(
left, weights2, right, weights3,
boundary, boundaryWeights, indices
);
}
else
{
terrain.AddTriangleUnperturbed(
HexMetrics.Perturb(left), HexMetrics.Perturb(right), boundary
);
terrain.AddTriangleCellData(
indices, weights2, weights3, boundaryWeights
);
}
}
void TriangulateCornerCliffTerraces(Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell)
{
float b = 1f / (leftCell.Elevation - beginCell.Elevation);
b = b < 0 ? -b : b;
Vector3 boundary = Vector3.Lerp(begin, left, b);
Color boundaryColor = Color.Lerp(beginCell.Color, leftCell.Color, b);
TriangulateBoundaryTriangle(right, rightCell, begin, beginCell, boundary, boundaryColor);
if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope)
{
TriangulateBoundaryTriangle(left, leftCell, right, rightCell, boundary, boundaryColor);
}
else
{
AddTriangle(left, right, boundary);
AddTriangleColor(leftCell.Color, rightCell.Color, boundaryColor);
}
}
public void AddWall(EdgeVertices near, HexCell nearCell, EdgeVertices far, HexCell farCell, bool hasRiver, bool hasRoad)
{
bool shouldAddWall = nearCell.Walled != farCell.Walled &&
!nearCell.IsUnderwater && !farCell.IsUnderwater &&
nearCell.GetEdgeType(farCell) != HexEdgeType.Cliff;
if (shouldAddWall)
{
AddWallSegment(near.v1, far.v1, near.v2, far.v2);
if (hasRiver || hasRoad)
{
AddWallCap(near.v2, far.v2);
AddWallCap(far.v4, near.v4);
}
else
{
AddWallSegment(near.v2, far.v2, near.v3, far.v3);
AddWallSegment(near.v3, far.v3, near.v4, far.v4);
}
AddWallSegment(near.v4, far.v4, near.v5, far.v5);
}
}
// Triangulate a corner with half terraces, half flat - Cliff on the left
void TriangulateCornerCliffTerraces(Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell)
{
float b = 1f / (leftCell.Elevation - beginCell.Elevation);
if (b < 0)
{
b = -b;
}
Vector3 boundary = Vector3.Lerp(HexMetrics.Perturb(begin), HexMetrics.Perturb(left), b); // boundary is on a pertubed slope
Color boundaryColor = Color.Lerp(beginCell.Color, leftCell.Color, b);
TriangulateBoundaryTriangle(right, rightCell, begin, beginCell, boundary, boundaryColor);
if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope)
{
TriangulateBoundaryTriangle(left, leftCell, right, rightCell, boundary, boundaryColor);
}
else
{
terrain.AddTriangleUnpertubed(HexMetrics.Perturb(left), HexMetrics.Perturb(right), boundary);
terrain.AddTriangleColor(leftCell.Color, rightCell.Color, boundaryColor);
}
}
private void TriangulateCorner(
Vector3 bottom, HexCell bottomCell,
Vector3 left, HexCell leftCell,
Vector3 right, HexCell rightCell
)
{
HexEdgeType leftEdgeType = bottomCell.GetEdgeType(leftCell);
HexEdgeType rightEdgeType = bottomCell.GetEdgeType(rightCell);
if (leftEdgeType == HexEdgeType.Slope)
{
if (rightEdgeType == HexEdgeType.Slope)
{
TriangulateCornerTerraces(
bottom, bottomCell, left, leftCell, right, rightCell
);
}
else if (rightEdgeType == HexEdgeType.Flat)
{
TriangulateCornerTerraces(
left, leftCell, right, rightCell, bottom, bottomCell
);
}
else
{
TriangulateCornerTerracesCliff(
bottom, bottomCell, left, leftCell, right, rightCell
);
}
}
else if (rightEdgeType == HexEdgeType.Slope)
{
if (leftEdgeType == HexEdgeType.Flat)
{
TriangulateCornerTerraces(
right, rightCell, bottom, bottomCell, left, leftCell
);
}
else
{
TriangulateCornerCliffTerraces(
bottom, bottomCell, left, leftCell, right, rightCell
);
}
}
else if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope)
{
if (leftCell.Elevation < rightCell.Elevation)
{
TriangulateCornerCliffTerraces(
right, rightCell, bottom, bottomCell, left, leftCell
);
}
else
{
TriangulateCornerTerracesCliff(
left, leftCell, right, rightCell, bottom, bottomCell
);
}
}
else
{
terrain.AddTriangle(bottom, left, right);
Vector3 indices;
indices.x = bottomCell.Index;
indices.y = leftCell.Index;
indices.z = rightCell.Index;
terrain.AddTriangleCellData(indices, weights1, weights2, weights3);
}
features.AddWall(bottom, bottomCell, left, leftCell, right, rightCell);
}
private void TriangulateConnection(
HexDirection direction, HexCell cell, EdgeVertices e1
)
{
HexCell neighbor = cell.GetNeighbor(direction);
if (neighbor == null)
{
return;
}
Vector3 bridge = HexMetrics.GetBridge(direction);
bridge.y = neighbor.Position.y - cell.Position.y;
EdgeVertices e2 = new EdgeVertices(
e1.v1 + bridge,
e1.v5 + bridge
);
bool hasRiver = cell.HasRiverThroughEdge(direction);
bool hasRoad = cell.HasRoadThroughEdge(direction);
if (hasRiver)
{
e2.v3.y = neighbor.StreamBedY;
Vector3 indices;
indices.x = indices.z = cell.Index;
indices.y = neighbor.Index;
if (!cell.IsUnderwater)
{
if (!neighbor.IsUnderwater)
{
TriangulateRiverQuad(
e1.v2, e1.v4, e2.v2, e2.v4,
cell.RiverSurfaceY, neighbor.RiverSurfaceY, 0.8f,
cell.HasIncomingRiver && cell.IncomingRiver == direction, indices
);
}
else if (cell.Elevation > neighbor.WaterLevel)
{
TriangulateWaterfallInWater(
e1.v2, e1.v4, e2.v2, e2.v4,
cell.RiverSurfaceY, neighbor.RiverSurfaceY,
neighbor.WaterSurfaceY, indices
);
}
}
else if (!neighbor.IsUnderwater && neighbor.Elevation > cell.WaterLevel)
{
TriangulateWaterfallInWater(
e2.v4, e2.v2, e1.v4, e1.v2,
neighbor.RiverSurfaceY, cell.RiverSurfaceY,
cell.WaterSurfaceY, indices
);
}
}
if (cell.GetEdgeType(direction) == HexEdgeType.Slope)
{
TriangulateEdgeTerraces(e1, cell, e2, neighbor, hasRoad);
}
else
{
TriangulateEdgeStrip(
e1, weights1, cell.Index,
e2, weights2, neighbor.Index, hasRoad
);
}
features.AddWall(e1, cell, e2, neighbor, hasRiver, hasRoad);
HexCell nextNeighbor = cell.GetNeighbor(direction.Next());
if (direction <= HexDirection.E && nextNeighbor != null)
{
Vector3 v5 = e1.v5 + HexMetrics.GetBridge(direction.Next());
v5.y = nextNeighbor.Position.y;
if (cell.Elevation <= neighbor.Elevation)
{
if (cell.Elevation <= nextNeighbor.Elevation)
{
TriangulateCorner(
e1.v5, cell, e2.v5, neighbor, v5, nextNeighbor
);
}
else
{
TriangulateCorner(
v5, nextNeighbor, e1.v5, cell, e2.v5, neighbor
);
}
}
else if (neighbor.Elevation <= nextNeighbor.Elevation)
{
TriangulateCorner(
e2.v5, neighbor, v5, nextNeighbor, e1.v5, cell
);
}
else
{
TriangulateCorner(
v5, nextNeighbor, e1.v5, cell, e2.v5, neighbor
);
}
}
}
private bool Search(HexCell fromCell, HexCell toCell, int speed)
{
searchFrontierPhase += 2;
if (searchFrontier == null)
{
searchFrontier = new PriorityQueue <HexCell>((x, y) => x.SearchPriority.CompareTo(y.SearchPriority));
}
else
{
searchFrontier.Clear();
}
fromCell.SearchPhase = searchFrontierPhase;
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
while (searchFrontier.Count > 0)
{
HexCell current = searchFrontier.Dequeue();
current.SearchPhase += 1;
if (current == toCell)
{
return(true);
}
int currentTurn = (current.Distance - 1) / speed;
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++)
{
HexCell neighbor = current.GetNeighbor(d);
if (neighbor == null || neighbor.SearchPhase > searchFrontierPhase)
{
continue;
}
if (neighbor.IsUnderwater || neighbor.Unit)
{
continue;
}
HexEdgeType edgeType = current.GetEdgeType(neighbor);
if (edgeType == HexEdgeType.Cliff)
{
continue;
}
int moveCost;
if (current.HasRoadThroughEdge(d))
{
moveCost = 1;
}
else if (current.Walled != neighbor.Walled)
{
continue;
}
else
{
moveCost = edgeType == HexEdgeType.Flat ? 5 : 10;
moveCost += neighbor.UrbanLevel + neighbor.FarmLevel + neighbor.PlantLevel;
}
int distance = current.Distance + moveCost;
int turn = (distance - 1) / speed;
if (turn > currentTurn)
{
distance = turn * speed + moveCost;
}
if (neighbor.SearchPhase < searchFrontierPhase)
{
neighbor.SearchPhase = searchFrontierPhase;
neighbor.Distance = distance;
neighbor.PathFrom = current;
neighbor.SearchHeuristic = neighbor.coordinates.DistanceTo(toCell.coordinates);
searchFrontier.Enqueue(neighbor);
}
else if (distance < neighbor.Distance)
{
neighbor.Distance = distance;
searchFrontier.Change(neighbor);
}
}
}
return(false);
}
// Fill the gap between each cell in the direction given
void TriangulateConnection(HexCell cell, HexDirection direction, EdgeVertices e1)
{
HexCell neighbor = cell.GetNeighbor(direction);
if (neighbor == null)
{
return;
}
// Build the bridge
Vector3 bridge = HexMetrics.GetBridge(direction);
bridge.y = neighbor.Position.y - cell.Position.y;
EdgeVertices e2 = new EdgeVertices(e1.v1 + bridge, e1.v5 + bridge);
bool hasRiver = cell.HasRiverThroughEdge(direction);
bool hasRoad = cell.HasRoadThroughEdge(direction);
if (hasRiver)
{
e2.v3.y = neighbor.StreamBedY;
if (!cell.IsUnderwater)
{
if (!neighbor.IsUnderwater)
{
// Normal river
TriangulateRiverQuad(e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbor.RiverSurfaceY, 0.8f, cell.HasIncomingRiver && cell.IncomingRiver == direction);
}
else if (cell.Elevation > neighbor.WaterLevel)
{
// Waterfall from cell to neighbor
TriangulateWaterfallInWater(e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbor.RiverSurfaceY, neighbor.WaterSurfaceY);
}
}
else if (!neighbor.IsUnderwater && neighbor.Elevation > cell.WaterLevel)
{
// Waterfall from neighbor to cell
TriangulateWaterfallInWater(e2.v4, e2.v2, e1.v4, e1.v2, neighbor.RiverSurfaceY, cell.RiverSurfaceY, cell.WaterSurfaceY);
}
}
if (cell.GetEdgeType(direction) == HexEdgeType.Slope)
{
TriangulateEdgeTerraces(e1, cell, e2, neighbor, hasRoad);
}
else
{
TriangulateEdgeStrip(e1, cell.Color, e2, neighbor.Color, hasRoad);
}
features.AddWall(e1, cell, e2, neighbor, hasRiver, hasRoad);
// Filling the gap
HexCell nextNeighbor = cell.GetNeighbor(direction.Next());
if (direction <= HexDirection.E && nextNeighbor != null)
{
Vector3 v5 = e1.v5 + HexMetrics.GetBridge(direction.Next());
v5.y = nextNeighbor.Position.y;
// Find the lowest cell
if (cell.Elevation <= neighbor.Elevation)
{
if (cell.Elevation <= nextNeighbor.Elevation)
{
TriangulateCorner(e1.v5, cell, e2.v5, neighbor, v5, nextNeighbor); // cell is the lowest
}
else
{
TriangulateCorner(v5, nextNeighbor, e1.v5, cell, e2.v5, neighbor); // nextNeighbor is the lowest
}
}
else if (neighbor.Elevation <= nextNeighbor.Elevation)
{
TriangulateCorner(e2.v5, neighbor, v5, nextNeighbor, e1.v5, cell); // neighbor is the lowest
}
else
{
TriangulateCorner(v5, nextNeighbor, e1.v5, cell, e2.v5, neighbor); // nextNeighbor is the lowest
}
}
}
