private static Hex FlatOffset(int offset, OffsetCoordinates coord)
{
int q = coord.Column;
int r = coord.Row - (int)((q + offset * (q & 1)) / 2);
return(new Hex(q, r));
}
private static Hex PointyOffset(int offset, OffsetCoordinates coord)
{
int r = coord.Row;
int q = coord.Column - (int)((r + offset * (r & 1)) / 2);
return(new Hex(q, r));
}
private Color GetColor(bool performColorCheck, OffsetCoordinates offsetCoordinates)
{
if (performColorCheck)
{
var checkA = new OffsetCoordinates(offsetCoordinates.Col - 1, offsetCoordinates.Row);
var checkB = new OffsetCoordinates(offsetCoordinates.Col - 1, offsetCoordinates.Row - 1);
var checkC = new OffsetCoordinates(offsetCoordinates.Col, offsetCoordinates.Row - 1);
var colA = HexagonDatabase.Instance[checkA].GetComponent <Hexagon>().Color;
var colB = HexagonDatabase.Instance[checkB].GetComponent <Hexagon>().Color;
var colC = HexagonDatabase.Instance[checkC].GetComponent <Hexagon>().Color;
if (colA == colB)
{
return(ColourDatabase.Instance.RandomColour(except: colA));
}
if (colB == colC)
{
return(ColourDatabase.Instance.RandomColour(except: colB));
}
if (colA == colC)
{
return(ColourDatabase.Instance.RandomColour(except: colA));
}
}
return(ColourDatabase.Instance.RandomColour());
}
FindNeighbors(OffsetCoordinates commonSpot, OffsetCoordinates[] otherSpots)
{
var indirectNeighbors = new List <Group>();
var directNeighbors = new List <Group>();
foreach (var g in GroupDatabase.Instance.Groups)
{
if (Utils.Contains(g, commonSpot))
{
var otherSpotCount = otherSpots.Count(s => Utils.Contains(g, s));
switch (otherSpotCount)
{
case 0:
indirectNeighbors.Add(g);
break;
case 1:
directNeighbors.Add(g);
break;
// case 2:
// // if it contains both of the other spots, it is the group itself, not one of the neighbors.
// break;
}
}
}
return(indirectNeighbors, directNeighbors);
}
/// <summary>
/// Checks if there are any colours that exists two times in the <paramref name="group"/>.
/// </summary>
/// <param name="group">The group to check.</param>
/// <param name="pairSpots">The spots where the color pair is located. (null if method returns false)</param>
/// <param name="thirdSpot">The third commonSpot, i.e. the commonSpot that has a different color. (Charlie if method returns false)</param>
/// <param name="foundColor">The colour that exists 2 times in this group. (Color.Clear if method returns false)</param>
private bool HasTwoColourPair(Group group, out OffsetCoordinates[] pairSpots,
out OffsetCoordinates thirdSpot, out Color foundColor)
{
var(ac, bc, cc) = Utils.GetColors(group);
if (ac == bc)
{
thirdSpot = group.Charlie;
foundColor = ac;
pairSpots = new[] { group.Alpha, group.Bravo };
return(true);
}
if (bc == cc)
{
thirdSpot = group.Alpha;
foundColor = bc;
pairSpots = new[] { group.Bravo, group.Charlie };
return(true);
}
if (ac == cc)
{
thirdSpot = group.Bravo;
foundColor = ac;
pairSpots = new[] { group.Alpha, group.Charlie };
return(true);
}
thirdSpot = group.Charlie;
foundColor = Color.clear;
pairSpots = null;
return(false);
}
public void EqualOffsetcoord(string name, OffsetCoordinates a, OffsetCoordinates b)
{
if (!(a.Column == b.Column && a.Row == b.Row))
{
Assert.Fail(name);
}
}
/// <summary>
/// Return offset coordinates of the neigboring tile in the specified direction.
/// </summary>
/// <param name="hex">Hex base.</param>
/// <param name="dir">Specified direction.</param>
/// <param name="pairs">Coordinate pairs.</param>
/// <returns></returns>
public static OffsetCoordinates GetNeighborFromDir(Hex hex, CubeDirections dir, OffsetCoordinates pairs)
{
CubeCoordinates cubePairs = OffsetToCube(hex, pairs.col, pairs.row);
switch (dir)
{
case CubeDirections.Left:
return(CubeToOffset(hex, cubePairs.x - 1, cubePairs.y + 1, cubePairs.z));
case CubeDirections.Right:
return(CubeToOffset(hex, cubePairs.x + 1, cubePairs.y - 1, cubePairs.z));
case CubeDirections.TopLeft:
return(CubeToOffset(hex, cubePairs.x, cubePairs.y + 1, cubePairs.z - 1));
case CubeDirections.BottomRight:
return(CubeToOffset(hex, cubePairs.x, cubePairs.y - 1, cubePairs.z + 1));
case CubeDirections.TopRight:
return(CubeToOffset(hex, cubePairs.x + 1, cubePairs.y, cubePairs.z - 1));
case CubeDirections.BottomLeft:
return(CubeToOffset(hex, cubePairs.x - 1, cubePairs.y, cubePairs.z + 1));
default:
Debug.LogError("Some unknown CubeDirections enum received.");
return(new OffsetCoordinates(-1, -1));
}
}
public Group(OffsetCoordinates alpha, OffsetCoordinates bravo, OffsetCoordinates charlie,
GroupOrientation orientation)
{
Alpha = alpha;
Bravo = bravo;
Charlie = charlie;
Orientation = orientation;
}
private IEnumerable <Group> AssembleHexagonGroups(int columnCount, int rowCount)
{
// 2-right even (a)
for (int col = 0; col < columnCount - 1; col += 2)
{
for (int row = 0; row < rowCount - 1; row++)
{
var alpha = new OffsetCoordinates(col, row);
var bravo = new OffsetCoordinates(col + 1, row + 1);
var charlie = new OffsetCoordinates(col + 1, row);
yield return(new Group(alpha, bravo, charlie, GroupOrientation.TwoRight));
}
}
// 2-left even (b)
for (int col = 0; col < columnCount - 1; col += 2)
{
for (int row = 0; row < rowCount - 1; row++)
{
var alpha = new OffsetCoordinates(col, row);
var bravo = new OffsetCoordinates(col, row + 1);
var charlie = new OffsetCoordinates(col + 1, row + 1);
yield return(new Group(alpha, bravo, charlie, GroupOrientation.TwoLeft));
}
}
// 2-right odd (c)
for (int col = 1; col < columnCount - 1; col += 2)
{
for (int row = 1; row < rowCount; row++)
{
var alpha = new OffsetCoordinates(col, row);
var bravo = new OffsetCoordinates(col + 1, row);
var charlie = new OffsetCoordinates(col + 1, row - 1);
yield return(new Group(alpha, bravo, charlie, GroupOrientation.TwoRight));
}
}
// 2-left odd (d)
for (int col = 1; col < columnCount - 1; col += 2)
{
for (int row = 0; row < rowCount - 1; row++)
{
var alpha = new OffsetCoordinates(col, row);
var bravo = new OffsetCoordinates(col, row + 1);
var charlie = new OffsetCoordinates(col + 1, row);
yield return(new Group(alpha, bravo, charlie, GroupOrientation.TwoLeft));
}
}
}
public Vector2f GetTopLeftCorner(AxialCoordinates position)
{
OffsetCoordinates offsetCoords = position;
return(new Vector2f(
(offsetCoords.Row & 1) * HorizontalSize / 2 + HorizontalSize * offsetCoords.Column,
offsetCoords.Row * (VerticalSize - EdgeLength / 2)
));
}
private IEnumerator Put(GameObject hex, OffsetCoordinates coords)
{
// set in hexagon database
HexagonDatabase.Instance[coords] = hex;
// sync the position of the GameObject
yield return
(hex.GetComponent <Hexagon>().MoveTo(coords.ToUnity(), 0.25f));
}
private void Explode(OffsetCoordinates coords)
{
var hex = HexagonDatabase.Instance[coords];
HexagonDatabase.Instance.MarkAsDestroyed(coords);
hex.GetComponent <Hexagon>().ExplodeSelf();
ScoreDatabase.Instance.OnHexagonExploded();
}
public HexCell GetCell(CubeCoordinates coordinates)
{
int x = OffsetCoordinates.FromCubeCoordinates(coordinates).X;
int z = OffsetCoordinates.FromCubeCoordinates(coordinates).Z;
if (z < 0 || z > cellCountZ - 1 || x < 0 || x > cellCountX - 1)
{
return(null);
}
return(cells[x, z]);
}
private void Place(OffsetCoordinates position, TerrainFactory terrainFactory)
{
var field = new Field(
world: this,
position: position
);
field.Create(terrainFactory);
this[position] = field;
}
private static IEnumerator Shift(int col, int row, int shiftCount, GameObject hex, Action callback)
{
Utils.LogConditional($"{nameof(GridShifter)}.{nameof(Shift)}: shifting... " +
$"pos: [{col}, {row}] shiftCount: {shiftCount} {nameof(hex)}: {hex}");
// data shift can be instant, nothing will/should interfere
HexagonDatabase.Swap(col, row, row - shiftCount);
var newCoords = new OffsetCoordinates(col, row - shiftCount);
yield return
(hex.GetComponent <Hexagon>().MoveTo(newCoords.ToUnity(), 0.5f));
callback();
}
private void BuildHexagonGrid(int columnCount, int rowCount)
{
for (var col = 0; col < columnCount; col++)
{
for (var row = 0; row < rowCount; row++)
{
var performColorCheck = (col > 0) && (row > 0);
var offsetCoordinates = new OffsetCoordinates(col, row);
var hex = HexagonCreator.Instance.CreateHexagon(offsetCoordinates, false, performColorCheck);
hex.name = $"({col}, {row})";
HexagonDatabase.Instance[offsetCoordinates] = hex;
}
}
}
protected override void OnPaint(PaintEventArgs e)
{
var g = e.Graphics;
for (var x = 0; x < 6; x++)
{
for (var y = 0; y < 6; y++)
{
var offset = new OffsetCoordinates(x, y);
var cube = _grid.ToCubeCoordinates(offset);
var points = _grid.PolygonCorners(cube).Select(p => new System.Drawing.Point((int)p.X, (int)p.Y)).ToList();
points.Add(points[0]);
g.DrawLines(Pens.Brown, points.ToArray());
}
}
}
/// <summary>
/// DOES NOT REGISTER THE NEW HEXAGON WITH <see cref="HexagonDatabase"/>. MAKE IT YOURSELF.
/// </summary>
public GameObject CreateHexagon(OffsetCoordinates offsetCoordinates, bool isBomb, bool performColorCheck)
{
var prefab = isBomb ? PrefabDatabase.Instance.BombHexagon : PrefabDatabase.Instance.Hexagon;
var newHexagon = Instantiate(prefab, transform);
newHexagon.transform.position = offsetCoordinates.ToUnity();
var colour = GetColor(performColorCheck, offsetCoordinates);
newHexagon.GetComponent <Hexagon>().SetColor(colour);
return(newHexagon);
}
public void InitFlat(Hex hex, bool even = true)
{
Hex = hex;
//gameObject.transform.rotation = Quaternion.Euler(0,0,30);
if (even)
{
_coordinates = OffsetCoordinates.EvenFlatOffset(hex);
}
else
{
_coordinates = OffsetCoordinates.OddFlatOffset(hex);
}
var x = WorldY % 2 == 0 ? Mathf.Sqrt(3f) * WorldX : Mathf.Sqrt(3f) * (WorldX - 1) + (Mathf.Sqrt(3f) / 2f);
var y = WorldX % 2 == 0 ? 3f * WorldY / 2f : 3f * WorldY;
transform.position = new Vector3(x, 3f * WorldY / 2f);
}
public void TestConversionRoundtrip()
{
CubeCoordinates a = new CubeCoordinates(3, 4, -7);
OffsetCoordinates b = new OffsetCoordinates(1, -3);
var flatOdd = HexLayoutFactory.CreateFlatHexLayout(new Point(10, 15), new Point(35, 71), Offset.Odd);
var flatEven = HexLayoutFactory.CreateFlatHexLayout(new Point(10, 15), new Point(35, 71), Offset.Even);
var pointyOdd = HexLayoutFactory.CreatePointyHexLayout(new Point(10, 15), new Point(35, 71), Offset.Odd);
var pointyEven = HexLayoutFactory.CreatePointyHexLayout(new Point(10, 15), new Point(35, 71), Offset.Even);
EqualHex("conversion_roundtrip even-Q", a, flatEven.ToCubeCoordinates(flatEven.ToOffsetCoordinates(a)));
EqualOffsetcoord("conversion_roundtrip even-Q", b, flatEven.ToOffsetCoordinates(flatEven.ToCubeCoordinates(b)));
EqualHex("conversion_roundtrip odd-Q", a, flatOdd.ToCubeCoordinates(flatOdd.ToOffsetCoordinates(a)));
EqualOffsetcoord("conversion_roundtrip odd-Q", b, flatOdd.ToOffsetCoordinates(flatOdd.ToCubeCoordinates(b)));
EqualHex("conversion_roundtrip even-R", a, pointyEven.ToCubeCoordinates(pointyEven.ToOffsetCoordinates(a)));
EqualOffsetcoord("conversion_roundtrip even-R", b, pointyEven.ToOffsetCoordinates(pointyEven.ToCubeCoordinates(b)));
EqualHex("conversion_roundtrip odd-R", a, pointyOdd.ToCubeCoordinates(pointyOdd.ToOffsetCoordinates(a)));
EqualOffsetcoord("conversion_roundtrip odd-R", b, pointyOdd.ToOffsetCoordinates(pointyOdd.ToCubeCoordinates(b)));
}
private IEnumerator Refill(int col, int row, int refillSpawnRow, Action callback)
{
var fillTarget = new OffsetCoordinates(col, row);
var hex = HexagonCreator.Instance.CreateHexagon(new OffsetCoordinates(col, refillSpawnRow),
_shouldSpawnBomb, false);
if (_shouldSpawnBomb)
{
_shouldSpawnBomb = false;
}
// data shift can be instant, nothing will/should interfere
HexagonDatabase.Instance[fillTarget] = hex;
yield return
(hex.GetComponent <Hexagon>().MoveTo(fillTarget.ToUnity(), 0.5f));
callback();
}
public void InitPointy(Hex hex, bool even = true)
{
Hex = hex;
float x;
if (even)
{
_coordinates = OffsetCoordinates.EvenPointyOffset(hex);
x = WorldY % 2 == 0 ? Mathf.Sqrt(3f) * WorldX :
Mathf.Sqrt(3f) * (WorldX - 1) + (Mathf.Sqrt(3f) / 2f);
}
else
{
_coordinates = OffsetCoordinates.OddPointyOffset(hex);
x = WorldY % 2 == 0 ? Mathf.Sqrt(3f) * WorldX :
Mathf.Sqrt(3f) * (WorldX - 1) + (Mathf.Sqrt(3f) / 2f);
}
var y = WorldX % 2 == 0 ? 3f * WorldY / 2f : 3f * WorldY;
transform.position = new Vector3(x, 3f * WorldY / 2f);
}
public static bool Contains(Group g, OffsetCoordinates oc)
{
return(g.Alpha == oc || g.Bravo == oc || g.Charlie == oc);
}
public GameObject this[OffsetCoordinates offsetCoordinates]
{
get => HexagonGrid[offsetCoordinates.Col, offsetCoordinates.Row];
public Field this[OffsetCoordinates position]
{
get { return(fields[position.Column][position.Row]); }
set { fields[position.Column][position.Row] = value; }
}
public void Mock(IEnumerable <Player> players)
{
Size = new Vector2i(10, 10);
fields = new Field[Size.X][];
grid = new List <List <VertexArray> >();
for (int i = 0; i < Size.X; i++)
{
fields[i] = new Field[Size.Y];
grid.Add(new List <VertexArray>());
for (int j = 0; j < Size.Y; j++)
{
var position = new OffsetCoordinates(i, j);
if (i == 7 && j == 8)
{
Place(position, Forest.Factory);
}
else if (i == 8 && j >= 7 && j <= 9)
{
Place(position, Hill.Factory);
}
else if (i == 5 && j == 2)
{
Place(position, Grass.Factory);
}
else if (i >= 3 && i <= 7 && j >= 1 && j <= 3)
{
Place(position, Water.Factory);
}
else if (i >= 4 && i <= 6 && j >= 4 && j <= 5)
{
Place(position, Desert.Factory);
}
else
{
Place(position, Grass.Factory);
}
var apexes = Model.GetApexesPositions(new Vector2f(
position.Column * Model.HorizontalSize + (Model.HorizontalSize * 0.5f * (position.Row & 1)),
position.Row * (Model.VerticalSize - Model.EdgeLength / 2)
));
var vertex = new VertexArray(PrimitiveType.LinesStrip);
var color = Color.Red;
for (uint k = 0; k < apexes.Length; k++)
{
vertex.Append(new Vertex(apexes[k], color));
}
vertex.Append(new Vertex(apexes[0], color));
grid[i].Add(vertex);
}
}
var unitPosition1 = new OffsetCoordinates(7, 7);
var unitPosition2 = new OffsetCoordinates(5, 7);
var unitPosition3 = new OffsetCoordinates(7, 8);
var unitPosition4 = new OffsetCoordinates(5, 8);
var unitPosition5 = new OffsetCoordinates(6, 7);
var unitPosition6 = new OffsetCoordinates(6, 8);
var improvementPosition = new OffsetCoordinates(6, 6);
var depositPosition = new OffsetCoordinates(8, 8);
var player1 = players.First();
var player2 = players.Skip(1).First();
this[unitPosition1].Create(Archer.Factory, player1);
this[unitPosition2].Create(Archer.Factory, player2);
this[unitPosition3].Create(Swordsman.Factory, player1);
this[unitPosition4].Create(Swordsman.Factory, player2);
this[unitPosition5].Create(Worker.Factory, player1);
this[unitPosition6].Create(Worker.Factory, player2);
this[improvementPosition].Create(Farm.Factory, player1);
this[depositPosition].Create(Iron.Factory);
}
public static Hex OddPointyOffset(OffsetCoordinates coord) => PointyOffset(-1, coord);
public Field this[OffsetCoordinates index]
{
get { return(fields[index.Column][index.Row]); }
}
public bool Contains(OffsetCoordinates position) => position.Column >= 0 && position.Row >= 0 && position.Column < Size.X && position.Row < Size.Y;
public bool Contains(OffsetCoordinates position)
{
return(position.Column < Size.X && position.Row < Size.Y && position.Column >= 0 && position.Row >= 0);
}
