/// <summary> /// Returns all the coordinates of the neighbouring hexes. /// </summary> /// <returns>The neighbours.</returns> /// <param name="a">The cubecoordinate you want to know the neighbours of.</param> public static CubeCoordinate[] GetNeighbours (CubeCoordinate a) { CubeCoordinate[] neighbours = new CubeCoordinate[6]; for (byte i = 0; i < 6; i++) { neighbours [i] = GetNeighbour (a, i); } return neighbours; }
public void SetCubeData(Vector3 position, byte data) { CubeCoordinate chunkCoordinate = new CubeCoordinate(position, CubeCoordinate.CoordinateType.chunk); if (chunks.TryGetValue(chunkCoordinate.ToString(), out CubeChunk chunk)) { chunk.SetCubeData(position, data, true); } }
public void SetCubeData(Vector3 position, byte data) { Vector3 cubePosition = CubeMetrics.WorldPosition2CubePosition(position); CubeCoordinate chunkCoordinate = new CubeCoordinate(position, CubeCoordinate.CoordinateType.chunk); CubeCoordinate cubeCoordinate = new CubeCoordinate(position, CubeCoordinate.CoordinateType.cubeWorld); CubeChunk chunk = chunks[chunkCoordinate.ToString()]; chunk.SetCubeData(cubePosition, data, true); }
public void Destroy(CubeCoordinate coord) { if (cells.TryGetValue(coord, out var cell) == false) { return; } cell.block = null; }
public Vector3 Hex2World(CubeCoordinate hex) { var spacing = this.spacing; Vector3 position; position.y = spacing.y * (hex.z + 0.5f * hex.x); position.x = spacing.x * hex.x; position.z = 0; return(position); }
public static OffsetCoordinate CubeCoordToOffsetCoord(CubeCoordinate cubeCoordinate, bool isEven) { OffsetCoordinate offset = new OffsetCoordinate(); offset.y = cubeCoordinate.x; offset.x = isEven ? cubeCoordinate.z + (cubeCoordinate.x - (cubeCoordinate.x & 1)) / 2 : cubeCoordinate.z + (cubeCoordinate.x + (cubeCoordinate.x & 1)) / 2; return(offset); }
public static IEnumerable <CubeCoordinate> Fan(CubeCoordinate center, int radius) { for ( ; radius >= 0; --radius) { foreach (var position in Arc(center, radius)) { yield return(position); } } }
public byte GetCubeData(Vector3 position) { CubeCoordinate chunkCoordinate = new CubeCoordinate(position, CubeCoordinate.CoordinateType.chunk); if (chunks.TryGetValue(chunkCoordinate.ToString(), out CubeChunk chunk)) { return(chunk.GetCubeData(position)); } return(byte.MinValue); }
public CubeCoordinate GetAdjacentCoordinate(params AdjacentDirection[] dirs) { CubeCoordinate temp = new CubeCoordinate(x, y, z); for (int i = 0; i < dirs.Length; i++) { temp = temp.GetAdjacentCoordinate(dirs[i]); } return(temp); }
private Transform Spawn( CubeCoordinate hexPosition ) { var mesh = Instantiate<GameObject>( hexMesh ); mesh.name = hexPosition.ToString(); var trans = mesh.transform; trans.parent = transform; trans.localPosition = hexPosition.ToWorldPosition(); trans.localRotation = Quaternion.identity; trans.localScale = Vector3.one; return trans; }
public static CubeCoordinate OffsetCoordToCubeCoord(OffsetCoordinate offsetCoordinate) { CubeCoordinate cube = new CubeCoordinate(); cube.x = offsetCoordinate.y; cube.z = offsetCoordinate.IsEven() ? offsetCoordinate.x - (offsetCoordinate.y - (offsetCoordinate.y & 1)) / 2 : offsetCoordinate.x - (offsetCoordinate.y + (offsetCoordinate.y & 1)) / 2; cube.y = -cube.x - cube.z; return(cube); }
private int CalculateFewestNumberOfSteps(IEnumerable <string> stepsTaken) { var location = new CubeCoordinate(0, 0, 0); foreach (var step in stepsTaken) { location = ApplyStep(step, location); } return(CalculateDistanceFromZero(location)); }
ICell IBoard.this[CubeCoordinate coord] { get { if (cells.TryGetValue(coord, out var cell)) { return(cell); } else { return(null); } } }
private Transform Spawn(CubeCoordinate hexPosition) { var mesh = Instantiate <GameObject>(template); mesh.name = hexPosition.ToString(); var trans = mesh.transform; trans.parent = transform; trans.localPosition = Hex2World(hexPosition); trans.localRotation = Quaternion.identity; trans.localScale = Vector3.one; return(trans); }
public CubeChunk GetAdjacentChunk(CubeChunk chunk, AdjacentDirection direction) { CubeCoordinate adjChunkCoordinate = chunk.ChunkCoordinate.GetAdjacentCoordinate(direction); if (chunks.ContainsKey(adjChunkCoordinate.ToString())) { return(chunks[adjChunkCoordinate.ToString()]); } else { return(null); } }
/// <summary> /// Method that contains the algorithm for placement of a hex. /// </summary> /// <param name="c">The cubecoordiante of the hex you want to get through the algorithm.</param> /// <param name="mapsize">Size of the map.</param> /// <param name="layer">What kind of layer this layer should be.</param> private void PlacementAlgorithm(CubeCoordinate c, sbyte mapSize, GroundType layer) { // Determine the chance this tile has to be placed. This calculation makes sure that tiles closer to the middle have a higher chance to spawn, then we multiply it by a facter determined by the type of layer we are talking about so that we for example have mountains be placed more in the middle of the map. float chance = ( (c.x * c.x) / (3.0f * mapSize * mapSize) + (c.y * c.y) / (3.0f * mapSize * mapSize) + (c.z * c.z) / (3.0f * mapSize * mapSize) ) * (Ground.CenterFactor(layer)); // Perlin noise returns a value between 0.0-1.0 if (Mathf.Clamp(Mathf.PerlinNoise ( _randomMultiplier * (c.x + mapSize), _randomMultiplier * (c.y + mapSize)), 0f, 1f) >= chance) { PlaceHex(c, layer); } }
/// <summary> /// Creates a hexagon at an axial position /// </summary> /// <returns>The created hexagon.</returns> /// <param name="a">The axial coordinate to place the hexagon on to.</param> /// <param name="type">The type of hexagon that should be placed</param> public Hexagon CreateHexagon(CubeCoordinate c, GroundType type) { GameObject hObj = GameObject.Instantiate( HexagonPrefab, HexCalculation.HexToWorld(c), HexagonPrefab.transform.rotation) as GameObject; Color tileColor = Ground.GroundColor(type); HexController hCon= hObj.GetComponent<HexController>(); hCon.SetColor (tileColor); hObj.transform.SetParent (this.gameObject.transform); return new Hexagon (c, type, hCon); }
/// <summary> /// Creates one layer of hexagons using a few other methods (PlacementAlgorithm and PlaceHex). /// </summary> /// <param name="mapsize">Size of the map.</param> /// <param name="layer">What kind of layer this layer should be.</param> private void CreateLayer(sbyte mapSize, GroundType layer) { // create a world of size 'mapsize' in each direction (x, y, z) for (sbyte x = (sbyte) -mapSize; x <= mapSize; x++) { for (sbyte y = (sbyte) -mapSize; y <= mapSize; y++) { // the z value has to be determined by the x and y sbyte z = (sbyte)(-x - y); // check if the z value also listens to the grid size if (z >= -mapSize && z <= mapSize) { CubeCoordinate coordinate = new CubeCoordinate (x, y, z); PlacementAlgorithm(coordinate, mapSize, layer); } } } }
/// <summary> /// A* algorithm /// </summary> public List<CubeCoordinate> GetPath(CubeCoordinate start, CubeCoordinate end) { Hexagon startHex = _grid.GetHexagonAtPosition(start.ToAxial()); Hexagon endHex = _grid.GetHexagonAtPosition(end.ToAxial()); if (startHex == null || endHex == null) return null; if (startHex.occupied || endHex.occupied) return null; PriorityQueue frontier = new PriorityQueue(); frontier.Enqueue(start, 0); Dictionary<CubeCoordinate, CubeCoordinate> came_from = new Dictionary<CubeCoordinate, CubeCoordinate>(); Dictionary<CubeCoordinate, int> cost_so_far = new Dictionary<CubeCoordinate, int>(); cost_so_far.Add(start, 0); while (frontier.Count != 0) { CubeCoordinate current = frontier.Dequeue(); if (current.Equals(end)) break; foreach (CubeCoordinate neighbour in HexCalculation.GetNeighbours(current)) { Hexagon hex = _grid.GetHexagonAtPosition(neighbour.ToAxial()); if (hex != null && !hex.occupied) { int new_cost = cost_so_far[current] + hex.cost; if (!cost_so_far.ContainsKey(neighbour) || new_cost < cost_so_far[neighbour]) { if (cost_so_far.ContainsKey(neighbour)) cost_so_far[neighbour] = new_cost; else cost_so_far.Add(neighbour, new_cost); int priority = new_cost + HexCalculation.GetDistance(neighbour, end); frontier.Enqueue(neighbour, priority); if (came_from.ContainsKey(neighbour)) came_from[neighbour] = current; else came_from.Add(neighbour, current); } } } } return RetracePath (start, end, came_from); }
private int CalculateFurthestDistance(IEnumerable <string> stepsTaken) { var location = new CubeCoordinate(0, 0, 0); var maxDistance = 0; foreach (var step in stepsTaken) { location = ApplyStep(step, location); var distance = CalculateDistanceFromZero(location); if (distance > maxDistance) { maxDistance = distance; } } return(maxDistance); }
private IEnumerable <Cell> FindSplashArea(CubeCoordinate target) { Cell cell = null; foreach (var direction in FlatTopDirection.around) { if (map.TryGetValue(target + direction, out cell) == false) { continue; } if (cell.block == null) { continue; } yield return(cell); } }
private Cell FindCellHasBlock(CubeCoordinate position, IEnumerable <CubeCoordinate> directions) { foreach (var dir in directions) { var next = position + dir; if (map.ContainsKey(next) == false) { continue; } if (map[next].block == null) { continue; } return(map[next]); } return(null); }
Stack <Vector3> GetPath(CubeCoordinate start, CubeCoordinate end) { path.Clear(); map.Clear(); tempNodes.Clear(); PathNode final = SearchRoad(start, end); while (final.previous != null) { final = final.previous; path.Push(final.coordinate.ToVector3(CubeCoordinate.CoordinateType.cubeWorld) + (Vector3.up * CubeMetrics.CUBE_SIDE_LENGTH * 0.5f)); } if (path.Count > 0) { path.Pop();//第一个坐标就是自己的位置 ,出栈不要. } return(path); }
bool GetAdjacentPath(CubeCoordinate coordinate, CubeOrientate orientate, out CubeCoordinate result) { AdjacentDirection temp = AdjacentDirection.front; switch (orientate) { case CubeOrientate.back: temp = AdjacentDirection.back; break; case CubeOrientate.left: temp = AdjacentDirection.left; break; case CubeOrientate.right: temp = AdjacentDirection.right; break; } if (HasCube(coordinate.GetAdjacentCoordinate(temp, AdjacentDirection.up, AdjacentDirection.up))) { result = coordinate.GetAdjacentCoordinate(temp, AdjacentDirection.up, AdjacentDirection.up); return(false); } if (HasCube(coordinate.GetAdjacentCoordinate(temp, AdjacentDirection.up))) { result = coordinate.GetAdjacentCoordinate(temp, AdjacentDirection.up); return(true); } if (HasCube(coordinate.GetAdjacentCoordinate(temp))) { result = coordinate.GetAdjacentCoordinate(temp); return(true); } if (HasCube(coordinate.GetAdjacentCoordinate(temp, AdjacentDirection.down))) { result = coordinate.GetAdjacentCoordinate(temp, AdjacentDirection.down); return(true); } result = new CubeCoordinate(0, 0, 0); return(false); }
void TriangulateByData() { Clear(); for (int y = 0; y < CubeMetrics.CHUNK_WIDTH; y++) { for (int z = 0; z < CubeMetrics.CHUNK_WIDTH; z++) { for (int x = 0; x < CubeMetrics.CHUNK_WIDTH; x++) { byte d = cubes[x + y * CubeMetrics.CHUNK_WIDTH * CubeMetrics.CHUNK_WIDTH + z * CubeMetrics.CHUNK_WIDTH]; CubeData data = CubeData.ToCubeData(d); if (data.active) { CubeCoordinate coordinate = new CubeCoordinate(x, y, z); TriangulateCube(x, y, z, data); } } } } Apply(); }
public static IEnumerable <CubeCoordinate> Ring(CubeCoordinate center, int radius) { if (radius <= 0f) { yield return(center); yield break; } var position = center + (around[4] * radius); foreach (var dir in around) { for (var i = 0; i < radius; ++i) { yield return(position); position += dir; } } }
Dictionary <string, CubeCoordinate> GetCoordinateByBounds(Bounds bounds) { tempCoordinate.Clear(); float delta = CubeMetrics.CHUNK_WIDTH * CubeMetrics.CUBE_SIDE_LENGTH; //根据包围盒计算出需要显示的所有chunk的坐标 for (float y = bounds.min.y; y <= bounds.max.y; y += delta) { for (float z = bounds.min.z; z <= bounds.max.z; z += delta) { for (float x = bounds.min.x; x <= bounds.max.x; x += delta) { CubeCoordinate chunkCoordinate = new CubeCoordinate(new Vector3(x, y, z), CubeCoordinate.CoordinateType.chunk); tempCoordinate.Add(chunkCoordinate.ToString(), chunkCoordinate); } } } return(tempCoordinate); }
private List<CubeCoordinate> RetracePath (CubeCoordinate start, CubeCoordinate end, Dictionary<CubeCoordinate, CubeCoordinate> steps) { List<CubeCoordinate> path = new List<CubeCoordinate>(); bool done = false; CubeCoordinate current = end; UnityEngine.Debug.Log(steps.Count + ", " + end); // foreach (KeyValuePair<CubeCoordinate, CubeCoordinate> pair in steps) { // UnityEngine.Debug.Log(pair.Key + ", " + pair.Value); // } while (!done) { path.Add(current); if (steps.ContainsKey(current)) current = steps[current]; else done = true; } path.Reverse(); return path; }
private CubeCoordinate ApplyStep(string direction, CubeCoordinate location) { switch (direction) { case North: location.Y += 1; location.Z -= 1; break; case NorthEast: location.X += 1; location.Z -= 1; break; case SouthEast: location.X += 1; location.Y -= 1; break; case South: location.Y -= 1; location.Z += 1; break; case SouthWest: location.X -= 1; location.Z += 1; break; case NorthWest: location.X -= 1; location.Y += 1; break; } return(location); }
public HexTile[] GetNeighborsInRange(int radius) { HashSet <HexTile> tiles = new HashSet <HexTile>(); for (int dx = -radius; dx <= radius; ++dx) { for (int dy = Mathf.Max(-radius, -dx - radius); dy <= Mathf.Min(radius, -dx + radius); ++dy) { int dz = -dx - dy; var center = new OffsetCoordinate(this.x, this.y); var offsetCube = new CubeCoordinate(dx, dy, dz); HexTile neighbor = HexTile.FindByOffset(center, HexUtils.CubeCoordToOffsetCoord(offsetCube, center.IsEven())); if (neighbor != null) { tiles.Add(neighbor); } } } HexTile[] results = new HexTile[tiles.Count]; tiles.CopyTo(results); return(results); }
public static int Distance( CubeCoordinate left, CubeCoordinate right ) { var x = Mathf.Abs( left.x - right.x ); var y = Mathf.Abs( left.y - right.y ); var z = Mathf.Abs( left.z - right.z ); return Mathf.Max( x, y, z ); }
/// <summary> /// Rounds a value to the neirest cubecoordinate /// </summary> /// <returns>The rounded cubecoordinate.</returns> /// <param name="h">The cubecoordinate to round.</param> public static CubeCoordinate HexRound (CubeCoordinate h) { // This code does not seem to be neccesary since sbytes cannot contain decimal values, this might cause an issue though. sbyte rx = h.x; // Math.Round (h.x); sbyte ry = h.y; // Math.Round (h.y); sbyte rz = h.z; // Math.Round (h.z); // end byte x_diff = (byte)Math.Abs (rx - h.z); byte y_diff = (byte)Math.Abs (ry - h.y); byte z_diff = (byte)Math.Abs (rz - h.z); if (x_diff > y_diff && x_diff > z_diff) { rx = (sbyte)(-ry - rz); } else if (y_diff > z_diff) { ry = (sbyte)(-rx - rz); } else { rz = (sbyte)(-rx - ry); } return new CubeCoordinate (rx, ry, rz); }
/// <summary> /// Converts a cubecoordinate array to an axialcoordinate array. /// </summary> /// <returns>Array of axialcoordinates.</returns> /// <param name="cubes">The array of cubecoordinates to convert.</param> public static AxialCoordinate[] ToAxials (CubeCoordinate[] cubes) { List<AxialCoordinate> axial_results = new List<AxialCoordinate> (); foreach (CubeCoordinate c in cubes) { axial_results.Add (c.ToAxial ()); } return axial_results.ToArray (); }
/// <summary> /// Returns an array of cubecoordinates which form a line from one point to another. /// </summary> /// <returns>Array of cubecoordinates which form a line from the start position to the end position.</returns> /// <param name="a">Cubecoordinate (start position).</param> /// <param name="b">Cubecoordinate (end position).</param> public static CubeCoordinate[] GetLine (CubeCoordinate a, CubeCoordinate b) { byte n = GetDistance (a, b); List<CubeCoordinate> results = new List<CubeCoordinate> (); for (byte i = 0; i <= n; i++) { results.Add (HexRound (Lerp (a, b, (byte)(1.0 / n * i)))); } return results.ToArray (); }
/// <summary> /// Creates a hexagon of type land, these remove hexes that have already been placed. /// </summary> /// <param name="c">The coordinate of the hex we are going to place.</param> private void CreateLandHex(CubeCoordinate c) { Hexagon h = _grid.CreateHexagon (c, GroundType.Land); _grid.AddHexagonToGrid(h, true); }
/// <summary> /// Creates a hexagon of type mountain, these remove hexes that have already been placed. /// </summary> /// <param name="c">The coordinate of the hex we are going to place.</param> private void CreateMountainHex(CubeCoordinate c) { if (Random.Range(0, 10) < 4) { Hexagon h = _grid.CreateHexagon (c, GroundType.Mountain); _grid.AddHexagonToGrid(h, true); } }
public PriorityHex (CubeCoordinate cube, int priority) { this.c = cube; this.priority = priority; }
public static CubeCoordinate[] HexRing (CubeCoordinate c, byte radius) { List<CubeCoordinate> results = new List<CubeCoordinate> (); CubeCoordinate cube = HexAdd (c, HexScale (_offsets [4].ToCube (), radius)); for (byte i = 0; i < 6; i++) { for (byte j = 0; j < radius; j++) { results.Add (cube); cube = GetNeighbour (cube, i); } } return results.ToArray (); }
public Spawner(CubeCoordinate down) { this.down = down; }
public void Enqueue(CubeCoordinate c, int priority) { elements.Add(new PriorityHex(c, priority)); }
public int Distance(CubeCoordinate subject) { return(Distance(this, subject)); }
public bool Equal(CubeCoordinate c) { return(x == c.x && y == c.y && z == c.z); }
public Hexagon (CubeCoordinate c, GroundType type, HexController controller) : base (c) { WorldPos = HexCalculation.HexToWorld (CubePos); occupied = (type != GroundType.Land); _hexType = type; _controller = controller; if (occupied) _controller.SetIndicatorColor(new Color(1f,1f,1f,0.1f)); }
/// <summary> /// Scales a coordinate. /// </summary> /// <returns>The scaled coordinate.</returns> /// <param name="c">The original cubecoordinate.</param> /// <param name="scale">The scale to 'scale' by.</param> public static CubeCoordinate HexScale (CubeCoordinate c, byte scale) { return new CubeCoordinate ((sbyte)(c.x * scale), (sbyte)(c.y * scale), (sbyte)(c.z * scale)); }
bool IBoard.HasCell(CubeCoordinate coord) { return(cells.ContainsKey(coord)); }
/// <summary> /// Adds an offset to a given cubecoordinate /// </summary> /// <returns>The result of the addition.</returns> /// <param name="c">The original cubecoordinate.</param> /// <param name="a">The offset to give the origin cubecoordinate.</param> public static CubeCoordinate HexAdd (CubeCoordinate c, CubeCoordinate a) { return new CubeCoordinate ((sbyte)(c.x + a.x), (sbyte)(c.y + a.y), (sbyte)(c.z + a.z)); }
void IBoard.Drop(CubeCoordinate from, CubeCoordinate to) { ((IBoard)this).Swap(from, to); }
/// <summary> /// Returns all cubecoordinates in range of the given cubecoordinate. /// </summary> /// <returns>All cubecoordinates in range of the given coordinate.</returns> /// <param name="c">The center of the range to look in.</param> /// <param name="range">The range to look in.</param> public static CubeCoordinate[] Range (CubeCoordinate c, byte range) { List<CubeCoordinate> cube_results = new List<CubeCoordinate> (); for (sbyte dx = (sbyte)-range; dx <= range; dx++) { for (sbyte dy = (sbyte)Math.Max (-range, -dx - range); dy <= Math.Min (range, -dx + range); dy++) { sbyte dz = (sbyte)(-dx - dy); cube_results.Add (HexAdd (c, new CubeCoordinate (dx, dy, dz))); } } return cube_results.ToArray (); }
private void Update() { if (_previousMode != m_mode) { ChangeMode(m_mode); } switch (m_mode) { case Mode.DrawArea: DrawHexagon(HexGrid.DrawArea( m_grid.WorldToCoordinate(new Vector2(_center.position.x, _center.position.z)), m_rangeCenter), Color.cyan ); break; case Mode.DrawIntersectArea: DrawHexagon( HexGrid.DrawArea( m_grid.WorldToCoordinate(new Vector2(_pointA.position.x, _pointA.position.z)), m_rangeA), Color.blue ); DrawHexagon( HexGrid.DrawArea( m_grid.WorldToCoordinate(new Vector2(_pointB.position.x, _pointB.position.z)), m_rangeB), Color.yellow ); DrawHexagon( HexGrid.DrawIntersectArea( m_grid.WorldToCoordinate(new Vector2(_pointA.position.x, _pointA.position.z)), m_rangeA, m_grid.WorldToCoordinate(new Vector2(_pointB.position.x, _pointB.position.z)), m_rangeB), Color.green ); break; case Mode.RotateCoordinate: CubeCoordinate a = m_grid.WorldToCoordinate(new Vector2(_pointA.position.x, _pointA.position.z)); CubeCoordinate centerRotation = m_grid.WorldToCoordinate(new Vector2(_center.position.x, _center.position.z)); DrawHexagonColorRamp( new CubeCoordinate[] { centerRotation, a, HexGrid.RotateCoordinate(a, centerRotation, HexGrid.CubeRotation.CCW_60), HexGrid.RotateCoordinate(a, centerRotation, HexGrid.CubeRotation.CCW_120), HexGrid.RotateCoordinate(a, centerRotation, HexGrid.CubeRotation.CCW_180), HexGrid.RotateCoordinate(a, centerRotation, HexGrid.CubeRotation.CCW_240), HexGrid.RotateCoordinate(a, centerRotation, HexGrid.CubeRotation.CCW_300) }, Color.white, Color.blue ); break; case Mode.DrawRing: CubeCoordinate centerRing = m_grid.WorldToCoordinate(new Vector2(_center.position.x, _center.position.z)); DrawHexagon( HexGrid.DrawRing(centerRing, m_rangeCenter), Color.blue ); m_grid.DebugDrawHexagon(centerRing, Color.white); break; case Mode.DrawLargeRing: CubeCoordinate centerLargeRing = m_grid.WorldToCoordinate(new Vector2(_center.position.x, _center.position.z)); DrawHexagon( HexGrid.DrawLargeRing(centerLargeRing, m_rangeA, m_rangeB), Color.blue ); m_grid.DebugDrawHexagon(centerLargeRing, Color.white); break; default: break; } }
/// <summary> /// Creates a hexagon of type water, these do not remove hexes that have already been placed. /// </summary> /// <param name="c">The coordinate of the hex we are going to place.</param> private void CreateWaterHex(CubeCoordinate c) { Hexagon h = _grid.CreateHexagon (c, GroundType.Water); _grid.AddHexagonToGrid(h); }
private int CalculateDistanceFromZero(CubeCoordinate location) { return((Math.Abs(location.X) + Math.Abs(location.Y) + Math.Abs(location.Z)) / 2); }
/// <summary> /// Converts a hexagon coordinate to a world coordinate /// </summary> /// <returns>The world coordinate.</returns> /// <param name="a">The cubecoordinate to convert.</param> public static Vector2 HexToWorld (CubeCoordinate c) { return HexToWorld (c.ToAxial ()); }
/// <summary> /// Returns the distance between two cubecoordinates. /// </summary> /// <returns>The distance between two cubecoordinates.</returns> /// <param name="a">Cubecoordinate (start position).</param> /// <param name="b">Cubecoordinate (end position).</param> public static byte GetDistance (CubeCoordinate a, CubeCoordinate b) { return (byte)((Math.Abs (a.x - b.x) + Math.Abs (a.y - b.y) + Math.Abs (a.z - b.z)) / 2); }
/// <summary> /// Places a hex after it has been through the algorithm (PlacementAlgorithm). It determines what kind of hex it should be and calls the right method for placement of that type of hex. /// </summary> /// <param name="c">The cubecoordiante of the hex you want to get through the algorithm.</param> /// <param name="layer">What kind of layer this layer should be.</param> private void PlaceHex(CubeCoordinate c, GroundType layer) { switch (layer) { case GroundType.Water: CreateWaterHex(c); break; case GroundType.Land: CreateLandHex(c); break; case GroundType.Mountain: CreateMountainHex(c); break; } }
/// <summary> /// Returns one single neighbour in a single direction /// </summary> /// <returns>The neighbour.</returns> /// <param name="a">The cubecoordinate you want to know the neighbour of.</param> /// <param name="dir">The direction you want to look at.</param> private static CubeCoordinate GetNeighbour (CubeCoordinate a, byte dir) { return GetNeighbour (a.ToAxial (), dir).ToCube (); }
public static Vector3 Hex2World( CubeCoordinate hex ) { Vector3 position; position.y = 0; position.x = horizontalSpacing * (hex.x + 0.5f * hex.z); position.z = verticalSpacing * hex.z; return position; }
/// <summary> /// Lerps between two coordinates. /// </summary> /// <returns>The cubecoordinate that you are on.</returns> /// <param name="a">Cubecoordinate (start position).</param> /// <param name="b">Cubecoordinate (end position).</param> /// <param name="t">Percentage from 0-1 where 0 is the start position and 1 the end position.</param> public static CubeCoordinate Lerp (CubeCoordinate a, CubeCoordinate b, byte t) { return new CubeCoordinate ((sbyte)(a.x + (b.x - a.x) * t), (sbyte)(a.y + (b.y - a.y) * t), (sbyte)(a.z + (b.z - a.z) * t)); }
public List<CubeCoordinate> MovesInRange(CubeCoordinate start, byte range) { if (_grid.GetHexagonAtPosition(start.ToAxial()).occupied) { // If we start on an occupied hex return an empty list. return new List<CubeCoordinate>(); } List<CubeCoordinate> visited = new List<CubeCoordinate>(); try { visited.Add(start); Dictionary<byte, List<CubeCoordinate>> fringes = new Dictionary<byte, List<CubeCoordinate>>(); fringes.Add(0, new List<CubeCoordinate>()); fringes[0].Add(start); for (byte k = 1 /*k<1*/; k <= range; k++) { fringes.Add(k, new List<CubeCoordinate>()); foreach (CubeCoordinate c in fringes[(byte) (k-1)]) { foreach (CubeCoordinate neighbour in HexCalculation.GetNeighbours(c)) { if (!visited.Contains(neighbour) && !_grid.GetHexagonAtPosition(neighbour.ToAxial()).occupied) { visited.Add(neighbour); fringes[k].Add(neighbour); } } } } } catch (System.NullReferenceException nrf) { UnityEngine.Debug.Log("Something went wrong with the pathfinding: " + nrf.ToString()); // If something went wrong return an empty list. return new List<CubeCoordinate>(); } return visited; }
public int Distance( CubeCoordinate subject ) { return Distance( this, subject ); }