private void Awake() { if (transform.childCount == 0) { Destroy(gameObject); } else { //child = transform.GetChild(0).gameObject; border = GetComponentsInChildren <SpriteRenderer>()[0]; highlight = GetComponentsInChildren <SpriteRenderer>()[1]; hover = GetComponentsInChildren <SpriteRenderer>()[2]; ShowOverlay(false); highlight.enabled = false; string[] coordText = name.Split(','); coordinates = new OffsetCoord(int.Parse(coordText[0]), int.Parse(coordText[1])); for (int i = allNeighbours.Count - 1; i > -1; i--) { if (allNeighbours[i] == null || allNeighbours[i].Equals(null)) { allNeighbours.RemoveAt(i); } } } }
static public void EqualOffsetcoord(String name, OffsetCoord a, OffsetCoord b) { if (!(a.col == b.col && a.row == b.row)) { Tests.Complain(name); } }
public void AxialAndOffsetEqual(int axialX, int axialY, int offsetX, int offsetY, bool expected) { var axial = new AxialCoord(axialX, axialY); var offset = new OffsetCoord(offsetX, offsetY); Assert.True(axial == offset == expected); }
public static Vector2Int QFromCube(Vector3Int h, OffsetCoord offset = OffsetCoord.Odd) { int col = h.x; int row = h.y + (int)((h.x + (int)offset * (h.x & 1)) / 2); return(new Vector2Int(col, row)); }
public static Hex RoffsetToCube(int offset, OffsetCoord h) { int q = h.col - (int)((h.row + offset * (h.row & 1)) / 2); int r = h.row; int s = -q - r; return new Hex(q, r, s); }
public static Vector3Int QToCube(Vector2Int h, OffsetCoord offset = OffsetCoord.Odd) { int q = h.x; int r = h.y - (int)((h.x + (int)offset * (h.x & 1)) / 2); int s = -q - r; return(new Vector3Int(q, r, s)); }
public static CubeCoord OffsetToCube(OffsetCoord h) { int q = h.x - (h.y - (h.y & 1)) / 2; int r = h.y; int s = -q - r; return(new CubeCoord(q, r, s)); }
void Update() { OffsetCoord coord = OffsetCoord.RoffsetFromCube(OffsetCoord.EVEN, hex); Hex globalHex = FractionalHex.HexRound(Layout.PixelToHex(GlobalPoint)); name = "Hex Global{" + globalHex.q + ", " + globalHex.r + ", " + globalHex.s + "} " + "Offset{" + coord.col + ", " + coord.row + "} Cube{" + hex.q + ", " + hex.r + ", " + hex.s + "}"; }
static public Hex RoffsetToCube(int offset, OffsetCoord h) { int q = h.col - (int)((h.row + offset * (h.row & 1)) / 2); int r = h.row; int s = -q - r; return(new Hex(q, r, s)); }
public void OffsetToAxial(int x, int y, int expectedQ, int expectedR) { var offset = new OffsetCoord(x, y); var axial = offset.ToAxial(); Assert.AreEqual(expectedQ, axial.Q); Assert.AreEqual(expectedR, axial.R); }
public static Piece Piece(Piece piecePrefab, Player owner, int startRotation, OffsetCoord? startPosition = null) { Piece piece = Instantiate<Piece>(piecePrefab); piece.name = piecePrefab.name + " " + owner.Name; piece.Init(startRotation, startPosition); owner.pieces.Add(piece); return piece; }
static public Hex QoffsetToCube(OffsetCoord h, int offset) { int q = h.col; int r = h.row - (int)((h.col + offset * (h.col & 1)) / 2); int s = -q - r; return(new Hex(q, r, s)); }
public static CubeCoord OddColumnToCube(OffsetCoord o) { double x, y, z; x = o.Column; z = o.Row - (o.Column - (o.Column & 1)) / 2; y = -x - z; return(new CubeCoord(x, y, z)); }
public void OffsetToCubeTest(int x, int y, int expectedX, int expectedY, int expectedZ) { var offset = new OffsetCoord(x, y); var cube = offset.ToCube(); Assert.AreEqual(expectedX, cube.X); Assert.AreEqual(expectedY, cube.Y); Assert.AreEqual(expectedZ, cube.Z); }
public static CubeCoord EvenRowToCube(OffsetCoord o) { double x, y, z; x = o.Column - (o.Row + (o.Row & 1)) / 2; z = o.Row; y = -x - z; return(new CubeCoord(x, y, z)); }
public void DifferentTypeDifferentValueNotEqualTest(int cubeX, int cubeY, int cubeZ, int axialQ, int axialR, int offsetX, int offsetY) { var cube = new CubeCoord(cubeX, cubeY, cubeZ); var axial = new AxialCoord(axialQ, axialR); var offset = new OffsetCoord(offsetX, offsetY); Assert.AreNotEqual(cube, axial); Assert.AreNotEqual(cube, offset); Assert.AreNotEqual(axial, offset); }
static public Hex RoffsetToCube(int offset, OffsetCoord h) { int q = h.col - (int)((h.row + offset * (h.row & 1)) / 2); int r = h.row; int s = -q - r; if (offset != OffsetCoord.EVEN && offset != OffsetCoord.ODD) { throw new ArgumentException("offset must be EVEN (+1) or ODD (-1)"); } return new Hex(q, r, s); }
public static Vector3Int GetVectorInDirection(this Vector3Int pos, PointyDirection pointyDirection) { var hex = OffsetCoord.RFromUnity(pos); var hex2 = OffsetCoord.RoffsetToCube(new OffsetCoord(pos.y, pos.x)); var neighbour = hex.Neighbor((int)pointyDirection); var result2 = OffsetCoord.RoffsetFromCube(neighbour); var result1 = OffsetCoord.RToUnityCoords(neighbour); return(result1); }
public static Hex RoffsetToCube(OffsetCoord.Parity offset, OffsetCoord h) { var q = h.col - (h.row + (int)offset * (h.row & 1)) / 2; var r = h.row; var s = -q - r; if (offset != OffsetCoord.Parity.Even && offset != OffsetCoord.Parity.Odd) { throw new ArgumentException("offset must be EVEN (+1) or ODD (-1)"); } return(new Hex(q, r, s)); }
static public void TestOffsetRoundtrip() { Hex a = new Hex(3, 4, -7); OffsetCoord b = new OffsetCoord(1, -3); Tests.EqualHex("conversion_roundtrip even-q", a, OffsetCoord.QoffsetToCube(OffsetCoord.EVEN, OffsetCoord.QoffsetFromCube(OffsetCoord.EVEN, a))); Tests.EqualOffsetcoord("conversion_roundtrip even-q", b, OffsetCoord.QoffsetFromCube(OffsetCoord.EVEN, OffsetCoord.QoffsetToCube(OffsetCoord.EVEN, b))); Tests.EqualHex("conversion_roundtrip odd-q", a, OffsetCoord.QoffsetToCube(OffsetCoord.ODD, OffsetCoord.QoffsetFromCube(OffsetCoord.ODD, a))); Tests.EqualOffsetcoord("conversion_roundtrip odd-q", b, OffsetCoord.QoffsetFromCube(OffsetCoord.ODD, OffsetCoord.QoffsetToCube(OffsetCoord.ODD, b))); Tests.EqualHex("conversion_roundtrip even-r", a, OffsetCoord.RoffsetToCube(OffsetCoord.EVEN, OffsetCoord.RoffsetFromCube(OffsetCoord.EVEN, a))); Tests.EqualOffsetcoord("conversion_roundtrip even-r", b, OffsetCoord.RoffsetFromCube(OffsetCoord.EVEN, OffsetCoord.RoffsetToCube(OffsetCoord.EVEN, b))); Tests.EqualHex("conversion_roundtrip odd-r", a, OffsetCoord.RoffsetToCube(OffsetCoord.ODD, OffsetCoord.RoffsetFromCube(OffsetCoord.ODD, a))); Tests.EqualOffsetcoord("conversion_roundtrip odd-r", b, OffsetCoord.RoffsetFromCube(OffsetCoord.ODD, OffsetCoord.RoffsetToCube(OffsetCoord.ODD, b))); }
public void SetPivotHex(OffsetCoord coord, bool force = false) { foreach (GameHex gHex in GameHexes) { if (gHex.coord.col == coord.col && gHex.coord.row == coord.row) { SetPivotHex(gHex, force); return; } } Debug.LogWarning("SetPivotHex(OffsetCoord) Hex not found"); }
public override bool Equals(object obj) { if (obj == null) { return(false); } OffsetCoord o = (OffsetCoord)obj; if ((System.Object)o == null) { return(false); } return((Row == o.Row) && (Column == o.Column)); }
public void Init(int x, int y, Color a_colour) { coordinates = new OffsetCoord(x, y); neighbours = new Hex[6]; allNeighbours = new List <Hex>(); if (!highlight) { highlight = GetComponentsInChildren <SpriteRenderer>()[1]; } highlight.color = a_colour; }
public Hex GetHexFromPosition(Vector3 a_position) { a_position = transform.InverseTransformPoint(a_position); OffsetCoord offsetCoord = HexCoordinate.PositionToOffset(a_position); int index = offsetCoord.y * MapWidth + offsetCoord.x; if (index < MapWidth * mapHeight) { return(grid[index]); } return(null); }
public virtual void GetPath() { if (Brain == null) { return; } var current = Brain.Movement.Location; var curHex = OffsetCoord.RFromUnity(current); var tarhex = OffsetCoord.RFromUnity(Target); var line = FractionalHex.HexLinedraw(curHex, tarhex); foreach (var h in line) { MovementQueue.Enqueue(OffsetCoord.RToUnityCoords(h)); } }
protected override void BuildBoard() { name = "RectangleBoard"; GameHex newHex; //Hex[,] HexesArray = new Hex[columns, rows]; Hexes = new List <GameHex>(); LegalStartingHexesP1 = new List <GameHex>(); LegalStartingHexesP2 = new List <GameHex>(); for (int col = 0; col < columns; col++) { for (int row = 0; row < rows; row++) { Hex hex = OffsetCoord.RoffsetToCube(OffsetCoord.EVEN, new OffsetCoord(col, row)); //OffsetCoord coord = OffsetCoord.RoffsetFromCube(OffsetCoord.EVEN, hex); //HexesArray[coord.col, coord.row] = hex; newHex = ObjectFactory.GameHex(); newHex.transform.parent = transform; Hexes.Add(newHex); Destroy(newHex.GetComponent <Collider>()); newHex.SetPosition(hex); foreach (MeshRenderer corner in newHex.corners) { corner.gameObject.SetActive(true); } if (col == 0 && (row % 2 == 1 || rows == 1)) { LegalStartingHexesP1.Add(newHex); } else if (col == columns - 1 && (row % 2 == 0 || rows == 1)) { LegalStartingHexesP2.Add(newHex); } } } }
/// <summary> /// Instantiates a new tile at the coord passed in /// </summary> /// <param name="coord">The coord to be used</param> private void PlaceTile(OffsetCoord coord) { // Create the object var hexPrefabObject = hexPrefabs[Random.Range(0, hexPrefabs.Count)]; GameObject hex = Instantiate( hexPrefabObject, transform.position + CalculateWorldPosition(new Vector2(coord.Column, coord.Row)), Quaternion.Euler(new Vector3(0, Random.Range(0, 5) * 60, 0)), this.transform); hex.name = string.Format("Hex {0} {1}", coord.Column, coord.Row); // Set up the object HexObject hexObject = hex.GetComponent <HexObject>(); hexObject.hex = new Hex(CubeCoord.OddRowToCube(coord)); hexObject.Index = Instance.Hexes.Count; Instance.Hexes.Add(hexObject); }
/// <summary> /// Gets a hexagon. /// </summary> /// <param name="radius"></param> /// <param name="start"></param> /// <returns></returns> public static List <Vector3Int> GetHexagon(int radius, Vector3Int start) { var result = new List <Vector3Int>(); for (int q = -radius; q <= radius; q++) { int r1 = Math.Max(-radius, -q - radius); int r2 = Math.Min(radius, -q + radius); for (int r = r1; r <= r2; r++) { var hex = new Hex(q, r); var offset = OffsetCoord.RToUnityCoords(hex); var tilePos = new Vector3Int(start.x + offset.x, start.y + offset.y, 0); result.Add(tilePos); } } return(result); }
bool BuildColonies() { List <Distances> distanceMatrix = new List <Distances>(); var buildable = Colonies.Where(x => x.ColonyAction != ColonyAction.Building); var empty = EntityManager.GetAllUncolonized(); if (empty.Count == 0) { return(false); } foreach (var col in buildable) { foreach (var uncol in empty) { distanceMatrix.Add(new Distances() { colony = col, empty = uncol, distance = OffsetCoord.RFromUnity(col.Location).Distance(OffsetCoord.RFromUnity(uncol)) }); } } if (distanceMatrix.Count < 1) { return(false); } var ordered = distanceMatrix.OrderBy(x => x.distance); var design = Designs.Where(x => x.Value.Type == "ColonyShip").Random().Value; foreach (var col in ordered) { if (Resouces < design.Cost) { savingFor = design; savingTarget = col.colony; return(true); } col.colony.BuildShip(design); } return(true); }
void OnSceneGUI() { Layout.defaultLayout = new Layout(Layout.pointy, new Point(1, 1), new Point(0, 0)); if (Event.current != null) { GameHex gHex = target as GameHex; if (Event.current.type == EventType.MouseUp) { gHex.UpdatePosition(); } else if (Event.current.type == EventType.MouseDrag) { gHex.layer = Mathf.RoundToInt(gHex.transform.localPosition.y * 5); gHex.UpdateHex(new Point(gHex.transform.parent.transform)); gHex.coord = OffsetCoord.RoffsetFromCube(OffsetCoord.EVEN, gHex.hex); } } }
void Update() { counterText.text = $"{GameManager.Singleton.Generator.GetCurrentIteration()}/{GameManager.Singleton.WorldSettings.numberOfIterations}"; if (Mouse.current.rightButton.wasPressedThisFrame) { Vector2 mousePos = Mouse.current.position.ReadValue(); var p = Camera.main.ScreenToWorldPoint(new Vector3(mousePos.x, mousePos.y)); Hex hex = GameManager.Singleton.World.layout.PixelToHex(new Point(p.x, p.y)).HexRound(); OffsetCoord coord = OffsetCoord.RoffsetFromCube(WorldSettings.OFFFSET_COORD, hex); Hex wrap = HexUtils.WrapOffset(hex, GameManager.Singleton.World.size.x); OffsetCoord wcoord = OffsetCoord.RoffsetFromCube(WorldSettings.OFFFSET_COORD, wrap); print(string.Format("WrappedHex: {0}, {1} | WrappedCoords: {0}, {1}", hex.q, hex.r, coord.col, coord.row)); var obj = GameManager.Singleton.World.TileData[hex]; var hData = obj.hexData; var pl = GameManager.Singleton.World.GetPlateByID(hData.plateId); hexInfoText.text = $"Hex={hex.q}/{hex.r}/{hex.s} | {coord.col}/{coord.row}"; tileObjText.text = $"h={Math.Round(hData.height, 2)}|tmp={Math.Round(hData.temp, 1)}|tid={obj.TileInfo()}|a={hData.age}"; movementText.text = $"mv={hData.lastMoved}|" + $"em={hData.lastEmpty}|" + $"dir={pl.direction}|" + $"fm={hData.formingMoutain}|" + $"hs={hData.isHotSpot}"; plateDataText.text = $"plate={hData.plateId},spd={Math.Round(pl.movementSpeed, 1)},el={Math.Round(pl.elevation, 0)}"; plateData2Text.text = $"ocn={hData.isOcean},cst={hData.isCoast},cell={hData.cellid}"; SetTitleStr(hex.ToString()); SetValueOrCreate("height", $"h={hData.height.ToString("0.#####")}"); SetValueOrCreate("rivers", $"river={obj.RiversToString()}"); } if (Keyboard.current.hKey.wasPressedThisFrame) { ShowHexData(!hexPanel.activeSelf); } }
public void Init(int startRotation, OffsetCoord?startPosition = null) { OnMovementFinished = new MovementFinished(); OnPieceClicked = new PieceClicked(); GameHexes = new List <GameHex>(GetComponentsInChildren <GameHex>()); foreach (GameHex gHex in GameHexes) { gHex.OnHexMouseDown += OnHexMouseDown; gHex.layer = 1; gHex.UpdatePosition(); } FixCorners(); SetColourInner(InnerActive); SetColourOuter(OuterSelected); targetRotation = startRotation; LockRotation(); Point = Layout.HexToPixel(OffsetCoord.RoffsetToCube(OffsetCoord.EVEN, startPosition.GetValueOrDefault())); }
public static void TestConversionRoundtrip() { Hex a = new Hex(3, 4, -7); OffsetCoord b = new OffsetCoord(1, -3); Tests.EqualHex("conversion_roundtrip even-q", a, OffsetCoord.QoffsetToCube(OffsetCoord.EVEN, OffsetCoord.QoffsetFromCube(OffsetCoord.EVEN, a))); Tests.EqualOffsetcoord("conversion_roundtrip even-q", b, OffsetCoord.QoffsetFromCube(OffsetCoord.EVEN, OffsetCoord.QoffsetToCube(OffsetCoord.EVEN, b))); Tests.EqualHex("conversion_roundtrip odd-q", a, OffsetCoord.QoffsetToCube(OffsetCoord.ODD, OffsetCoord.QoffsetFromCube(OffsetCoord.ODD, a))); Tests.EqualOffsetcoord("conversion_roundtrip odd-q", b, OffsetCoord.QoffsetFromCube(OffsetCoord.ODD, OffsetCoord.QoffsetToCube(OffsetCoord.ODD, b))); Tests.EqualHex("conversion_roundtrip even-r", a, OffsetCoord.RoffsetToCube(OffsetCoord.EVEN, OffsetCoord.RoffsetFromCube(OffsetCoord.EVEN, a))); Tests.EqualOffsetcoord("conversion_roundtrip even-r", b, OffsetCoord.RoffsetFromCube(OffsetCoord.EVEN, OffsetCoord.RoffsetToCube(OffsetCoord.EVEN, b))); Tests.EqualHex("conversion_roundtrip odd-r", a, OffsetCoord.RoffsetToCube(OffsetCoord.ODD, OffsetCoord.RoffsetFromCube(OffsetCoord.ODD, a))); Tests.EqualOffsetcoord("conversion_roundtrip odd-r", b, OffsetCoord.RoffsetFromCube(OffsetCoord.ODD, OffsetCoord.RoffsetToCube(OffsetCoord.ODD, b))); }
public static void EqualOffsetcoord(String name, OffsetCoord a, OffsetCoord b) { if (!(a.col == b.col && a.row == b.row)) { Tests.Complain(name); } }