public RoadEdge(
Hex source,
Hex target,
HexDirections direction
) : base(source, target, direction)
{
}
public static HexDirections NextClockwise2(
this HexDirections direction
)
{
direction += 2;
return(direction <= HexDirections.Northwest ? direction : (direction - 6));
}
public void RotationArrowClicked(Arrow arr)
{
this.direction = arr.direction;
if ((int)direction < 2 || (int)direction == 5)
{
isFacingRight = true;
}
else
{
isFacingRight = false;
}
if (isFacingRight)
{
GetComponentInChildren <SpriteRenderer>().flipX = false;
}
else
{
GetComponentInChildren <SpriteRenderer>().flipX = true;
}
GetComponentInChildren <UnitDirection>().SetNewDirectionAndRotion(this.direction);
fieldOfVisionTiles = gridscr.ClearFogNormalVision(transform.position, direction, 6);
LocalPlayer.HandleFogOfWarHide();
}
void TriangulateConnection(HexCell cell, HexDirections direction, Vector3 v1, Vector3 v2)
{
HexCell neighbor = cell.GetNeighbors(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;
TriangulateConnectionTerrace(v1, v2, cell, v3, v4, neighbor);
// Add triagles betwen bridges.
HexCell nextNeighbor = cell.GetNeighbors(direction.Next());
if (direction <= HexDirections.E && nextNeighbor != null)
{
Vector3 v5 = v2 + HexMetrics.GetBridge(direction.Next());
v5.y = nextNeighbor.Elevation * HexMetrics.elevationStep;
AddTriangle(v2, v4, v5);
AddTriangleColor(cell.color, neighbor.color, nextNeighbor.color);
}
}
public static Vector3 GetWaterBridge(HexDirections direction, float radius)
{
return((
GetCorner((int)direction, radius) +
GetCorner((int)direction + 1, radius)
) * waterBlendFactor);
}
void Triangulate(HexCell cell)
{
for (HexDirections d = HexDirections.NE; d <= HexDirections.NW; d++)
{
Triangulate(d, cell);
}
}
public ClimateParameters(
HemisphereMode hemisphere,
HexDirections windDirection,
float evaporationFactor,
float highTemperature,
float lowTemperature,
float precipitationFactor,
float runoffFactor,
float seepageFactor,
float temperatureJitter,
float windStrength,
float hexOuterRadius,
int elevationMax,
int waterLevel
)
{
this.hemisphere = hemisphere;
this.windDirection = windDirection;
this.evaporationFactor = evaporationFactor;
this.highTemperature = highTemperature;
this.lowTemperature = lowTemperature;
this.precipitationFactor = precipitationFactor;
this.runoffFactor = runoffFactor;
this.seepageFactor = seepageFactor;
this.temperatureJitter = temperatureJitter;
this.windStrength = windStrength;
this.hexOuterRadius = hexOuterRadius;
this.elevationMax = elevationMax;
this.waterLevel = waterLevel;
}
public static CubeCoordinate Neighbour(Vector3 centre, HexDirections direction)
{
var d = Directions[direction];
var obj = new CubeCoordinate(centre.X + d.Position.X, centre.Y + d.Position.Y, centre.Z + d.Position.Z);
return(obj);
}
public static Vector3 GetSecondSolidCorner(
HexDirections direction,
float outerRadius
)
{
return(GetCorner((int)direction + 1, outerRadius) * solidFactor);
}
public bool HasRoadInDirection(
Hex hex,
HexDirections direction
)
{
if (!ContainsVertex(hex))
{
return(false);
}
List <RoadEdge> edges = (List <RoadEdge>)AdjacentEdges(hex);
if (edges != null && edges.Count > 0)
{
foreach (RoadEdge edge in edges)
{
if (edge.Direction == direction)
{
return(true);
}
}
}
return(false);
}
public HexDirections RotateDirection(HexDirections currentDir, HexRotation rotation)
{
if (rotation == HexRotation.Right)
{
var newDir = (int)currentDir + 1;
if (newDir == 6)
{
newDir = 0;
}
return((HexDirections)newDir);
}
else if (rotation == HexRotation.Left)
{
var newDir = (int)currentDir - 1;
if (newDir == -1)
{
newDir = 5;
}
return((HexDirections)newDir);
}
else
{
throw new Exception("Invalid rotation!");
}
}
public static HexDirections PreviousClockwise2(
this HexDirections direction
)
{
direction -= 2;
return(direction >= HexDirections.Northeast ? direction : direction + 6);
}
private Vector2 GetRoadInterpolators(
Hex source,
HexDirections direction,
Dictionary <HexDirections, bool> roadEdges
)
{
Vector2 interpolators;
// if (hex.HasRoadThroughEdge(direction)) {
if (roadEdges[direction])
{
interpolators.x = interpolators.y = 0.5f;
}
else
{
interpolators.x =
// hex.HasRoadThroughEdge(direction.Previous()) ?
// 0.5f : 0.25f;
roadEdges[direction.PreviousClockwise()] ?
0.5f : 0.25f;
interpolators.y =
// hex.HasRoadThroughEdge(direction.Next()) ?
// 0.5f : 0.25f;
roadEdges[direction.NextClockwise()] ?
0.5f : 0.25f;
}
return(interpolators);
}
public ElevationEdge(
Hex source,
Hex target,
HexDirections direction
) : base(source, target, direction)
{
}
public WaterTriangulationData TriangulateHexWaterShoreEdge(
Hex source,
Hex neighbor,
Dictionary <HexDirections, Hex> neighbors,
HexDirections direction,
HexRiverData riverData,
WaterTriangulationData triangulationData,
float hexOuterRadius,
int wrapSize
)
{
if (source.IsUnderwater)
{
if (
!neighbor.IsUnderwater
)
{
Vector3 center2 = neighbor.Position;
float hexInnerRadius =
HexagonPoint.OuterToInnerRadius(hexOuterRadius);
float hexInnerDiameter = hexInnerRadius * 2f;
// / | y
// / |
// | |
//source x/z | | target
// | |
// \ |
// \ | y
Vector3 waterShoreHexIndices;
waterShoreHexIndices.x =
waterShoreHexIndices.z = source.Index;
waterShoreHexIndices.y = neighbor.Index;
TriangulateWaterShore(
source,
neighbor,
waterShoreHexIndices,
direction,
neighbors,
riverData,
triangulationData.waterSurfaceCenter,
hexOuterRadius,
wrapSize,
this,
triangulationData.sourceWaterEdge,
triangulationData.neighborWaterEdge,
hexInnerDiameter
);
}
}
return(triangulationData);
}
public TerrainTriangulationData TriangulateHexTerrainEdge(
Hex hex,
Hex neighbor,
TerrainTriangulationData triangulationData,
Dictionary <HexDirections, Hex> neighbors,
HexDirections direction,
HexRiverData riverData,
FeatureContainer features,
Dictionary <HexDirections, bool> roadEdges,
Dictionary <HexDirections, ElevationEdgeTypes> elevationEdgeTypes,
float hexOuterRadius,
int wrapSize
)
{
triangulationData = TriangulateTerrainCenter(
riverData,
direction,
hex,
triangulationData,
hexOuterRadius,
wrapSize,
this,
features,
roadEdges
);
if (direction <= HexDirections.Southeast)
{
triangulationData = TriangulateTerrainConnection(
hex,
neighbor,
triangulationData,
direction,
riverData,
roadEdges,
elevationEdgeTypes,
hexOuterRadius,
wrapSize,
this,
features
);
// Adjust the other edge of the connection if there is a river through
// that edge.
triangulationData = TryTriangulateNeighborTerrainCorner(
hex,
neighbor,
triangulationData,
direction,
neighbors,
hexOuterRadius,
wrapSize,
this,
features
);
}
return(triangulationData);
}
/// <summary>
/// 获取到目标点的邻居节点;
/// </summary>
public IEnumerable <CoordPack <CubicHexCoord, HexDirections> > GetNeighbours(HexDirections directions)
{
foreach (var direction in GetDirections(directions))
{
CubicHexCoord point = GetDirection(direction);
yield return(new CoordPack <CubicHexCoord, HexDirections>(point, direction));
}
}
public TraversalEdge(
Hex source,
Hex target,
HexDirections direction
) : base(source, target, direction)
{
MovementCost = 0;
}
public HexEdge(
Hex source,
Hex target,
HexDirections direction
) : base(source, target)
{
Direction = direction;
}
public static HexDirections Opposite(this HexDirections direction)
{
// If the direction is less than 3, returns the opposite direction at
// HexDirections + 3. If the direction is greater than 3, loops back around
// the HexDirections enum and returns the opposite direction.
return((int)direction < 3 ? (direction + 3) : (direction - 3));
}
public static bool SetOutgoingRiver(
Hex source,
Hex target,
HexDirections direction,
ref RiverDigraph riverDigraph
)
{
if (
riverDigraph.HasOutgoingRiverInDirection(
source,
direction
)
)
{
return(false);
}
if (
!IsValidRiverDestination(
source,
target
)
)
{
return(false);
}
riverDigraph.RemoveOutgoingRivers(
source
);
if (
riverDigraph.HasIncomingRiverInDirection(
source,
direction
)
)
{
riverDigraph.RemoveIncomingRivers(
source
);
}
riverDigraph.RemoveIncomingRivers(target);
riverDigraph.AddVerticesAndEdge(
new RiverEdge(
source,
target,
direction
)
);
return(true);
// SetRoad((int)direction, false);
}
public static HexDirections PreviousClockwise(
this HexDirections direction
)
{
// If the hex direction is the first in the enum, wrap back and return the
// last enum value, otherwise return the preceding enum value.
return(direction == HexDirections.Northeast ? HexDirections.Northwest : (direction - 1));
}
public static HexDirections NextClockwise(
this HexDirections direction
)
{
// If the hex direction is the last in the enu, wrap forward and return the
// last enum value, otherwise return the next enum value.
return(direction == HexDirections.Northwest ? HexDirections.Northeast : (direction + 1));
}
public bool HasRiverClockwiseToDirection(
HexDirections direction,
int turns
)
{
return
(IncomingRivers[direction.ClockwiseRotation(turns)] ||
OutgoingRivers[direction.ClockwiseRotation(turns)]);
}
public bool HasRiverInDirection(
Hex hex,
HexDirections direction
)
{
return
(HasIncomingRiverInDirection(hex, direction) ||
HasOutgoingRiverInDirection(hex, direction));
}
public static Vector3 GetBridge(HexDirections direction, float outerRadius)
{
// Get a vector pointing from the edge of the solid region of one hexagon to the
// edge of the solid region of another hexagon.
return((
GetCorner((int)direction, outerRadius) +
GetCorner((int)direction + 1, outerRadius)
) * blendFactor);
}
public static Vector3 GetSolidEdgeMiddle(
HexDirections direction,
float outerRadius
)
{
return((
GetCorner((int)direction, outerRadius) +
GetCorner((int)direction + 1, outerRadius)
) * (0.5f * solidFactor));
}
public WaterTriangulationData TriangulateHexOpenWaterEdge(
Hex source,
Hex neighbor,
Dictionary <HexDirections, Hex> neighbors,
HexDirections direction,
WaterTriangulationData waterTriData,
TerrainTriangulationData terrainTriData,
float hexOuterRadius,
int wrapSize
)
{
if (source.IsUnderwater)
{
if (
!neighbor.IsUnderwater
)
{
waterTriData = TriangulateShoreOpenWater(
source,
neighbor,
waterTriData.waterSurfaceCenter,
waterTriData.sourceWaterEdge,
hexOuterRadius,
wrapSize,
this,
waterTriData
);
}
else
{
waterTriData = TriangulateOpenWaterCenter(
source,
waterTriData,
direction,
hexOuterRadius,
wrapSize,
this
);
waterTriData = TriangulateOpenWaterConnection(
source,
neighbor,
direction,
waterTriData,
terrainTriData,
neighbors,
hexOuterRadius,
wrapSize,
this
);
}
}
return(waterTriData);
}
public Vector3Int GetNextCellInDirection(Vector3Int current, HexDirections dir)
{
switch (dir)
{
case HexDirections.Right:
return(new Vector3Int(current.x + 1, current.y, 0));
case HexDirections.DownRight:
if (current.y % 2 == 0)
{
return(new Vector3Int(current.x, current.y - 1, 0));
}
else
{
return(new Vector3Int(current.x + 1, current.y - 1, 0));
}
case HexDirections.DownLeft:
if (current.y % 2 == 0)
{
return(new Vector3Int(current.x - 1, current.y - 1, 0));
}
else
{
return(new Vector3Int(current.x, current.y - 1, 0));
}
case HexDirections.Left:
return(new Vector3Int(current.x - 1, current.y, 0));
case HexDirections.UpLeft:
if (current.y % 2 == 0)
{
return(new Vector3Int(current.x - 1, current.y + 1, 0));
}
else
{
return(new Vector3Int(current.x, current.y + 1, 0));
}
case HexDirections.UpRight:
if (current.y % 2 == 0)
{
return(new Vector3Int(current.x, current.y + 1, 0));
}
else
{
return(new Vector3Int(current.x + 1, current.y + 1, 0));
}
default:
throw new Exception("Invalid direction!");
}
}
private TerrainTriangulationData TriangulateTerrainConnectionRoads(
Hex source,
Hex neighbor,
TerrainTriangulationData data,
HexDirections direction,
HexRiverData riverData,
Dictionary <HexDirections, bool> roadEdges,
Dictionary <HexDirections, ElevationEdgeTypes> elevationEdgeTypes,
float hexOuterRadius,
int wrapSize,
MapMeshChunkLayer roads
)
{
bool hasRoad = roadEdges[direction];
if (
// hex.GetEdgeType(direction) == ElevationEdgeTypes.Slope
elevationEdgeTypes[direction] == ElevationEdgeTypes.Slope
)
{
if (hasRoad)
{
TriangulateEdgeTerracesRoads(
data.centerEdgeVertices,
source,
data.connectionEdgeVertices,
neighbor,
hasRoad,
hexOuterRadius,
wrapSize,
roads
);
}
}
else
{
if (hasRoad)
{
TriangulateEdgeStripRoads(
data.centerEdgeVertices,
_weights1,
source.Index,
data.connectionEdgeVertices,
_weights2,
neighbor.Index,
hexOuterRadius,
wrapSize,
roads
);
}
}
return(data);
}
/// <summary>
/// Returns the coordinate origin Point for the given Hex in the given Direction
/// </summary>
public static Point HexOffset(Point hexCoordinate, HexDirections direction)
{
Point offset = new Point(0, 0);
if (hexCoordinate.Y % 2 == 0) //Is this row even?
{
switch (direction)
{
case HexDirections.NorthEast: offset = new Point(0, -1); break;
case HexDirections.NorthWest: offset = new Point(-1, -1); break;
case HexDirections.West: offset = new Point(-1, 0); break;
case HexDirections.SouthWest: offset = new Point(-1, 1); break;
case HexDirections.SouthEast: offset = new Point(0, 1); break;
case HexDirections.East: offset = new Point(1, 0); break;
default: break;
}
}
else // Is this row odd
{
switch (direction)
{
case HexDirections.NorthEast: offset = new Point(1, -1); break;
case HexDirections.NorthWest: offset = new Point(0, -1); break;
case HexDirections.West: offset = new Point(-1, 0); break;
case HexDirections.SouthWest: offset = new Point(0, 1); break;
case HexDirections.SouthEast: offset = new Point(1, 1); break;
case HexDirections.East: offset = new Point(1, 0); break;
default: break;
}
}
return offset;
}
/// <summary>
/// Returns the Direction opposite the given Direction
/// </summary>
public static HexDirections Opposite(HexDirections direction)
{
return RotateDirection(direction, 3);
}
/// <summary>
/// Returns the tileCoordinate of the Neighboring tile in the given direction for the given tileCoordinate
/// </summary>
public static Point Neighbor(Point hexCoordinate, HexDirections direction)
{
Point offset = HexOffset(hexCoordinate, direction);
hexCoordinate.X += offset.X;
hexCoordinate.Y += offset.Y;
return hexCoordinate;
}
/// <summary>
/// Returns the Direction after the rotating it the given amount
/// </summary>
/// <param name="direction">The Starting Direction</param>
/// <param name="amount">The number of Directions to Rotate</param>
public static HexDirections RotateDirection(HexDirections direction, int amount)
{
//Let's make sure our directions stay within the enumerated values.
if (direction < HexDirections.NorthEast || direction > HexDirections.NorthWest || Math.Abs(amount) > (int)HexDirections.NorthWest)
throw new InvalidOperationException("Directions out of range.");
direction += amount;
//Now we need to make sure direction stays within the proper range.
//C# does not allow modulus operations on enums, so we have to convert to and from int.
int n_dir = (int)direction % (int)HexDirections.NumberOfDirections;
if (n_dir < 0) n_dir = (int)HexDirections.NumberOfDirections + n_dir;
direction = (HexDirections)n_dir;
return direction;
}
