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; }