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