public int Distance(HexagonalTile target)
{
if (target == null)
{
return(-1);
}
int distanceX = Mathf.Abs(PosX - target.PosX);
int distanceY = Mathf.Abs(PosY - target.PosY);
int distanceZ = Mathf.Abs(PosZ - target.PosZ);
int resultDistance = Mathf.Max(Mathf.Max(distanceX, distanceY), distanceZ);
//int resultDistance = (distanceX + distanceY + distanceZ) / 2;
return(resultDistance);
}
private HexagonalTile NearestTileTo(Vector3 direction)
{
RaycastHit[] hits = Physics.RaycastAll(transform.position, direction, 2.0f);
Func <RaycastHit, double> dist = hit => Vector3.Distance(transform.position, hit.transform.position);
Array.Sort <RaycastHit>(hits, (t1, t2) => (int)(1000000 * (dist(t1) - dist(t2))));
DebugRaycast(direction, hits);
if (hits.Length > 0)
{
HexagonalTile result = hits[0].transform.GetComponentInParent <HexagonalTile>();
return(result);
}
return(null);
}
private Vector3Int NeighborInDirection(Vector3Int cell, Vector3 direction)
{
float maxd = float.MinValue;
Vector3Int winner = new Vector3Int();
Vector3 c = tilemap.CellToWorld(cell);
for (int i = 0; i < 6; i++)
{
Vector3Int nint = HexagonalTile.GetNeighbor(cell, i);
Vector3 n = tilemap.CellToWorld(HexagonalTile.GetNeighbor(cell, i));
float d = Vector3.Dot(direction, n - c);
if (d > maxd)
{
winner = nint;
maxd = d;
}
}
return(winner);
}
public void PlaceBuilding(BuildingTile building, Vector3Int position)
{
if (building)
{
tilemap.SetTile(position, building.centerTile);
if (building.ring1Tile.Length != 0)
{
var ring = HexagonalTile.GetHexagonalRing(position, 1);
foreach (Vector3Int t in ring)
{
if (Random.Range(0f, 1f) < building.ring1Probability)
{
tilemap.SetTile(t, building.ring1Tile[Random.Range(0, building.ring1Tile.Length)]);
if (building.flipAllowed && Random.Range(0, 2) != 0)
{
Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 180f, 0f), Vector3.one);
tilemap.SetTransformMatrix(t, matrix);
}
}
}
}
if (building.ring2Tile.Length != 0)
{
var ring = HexagonalTile.GetHexagonalRing(position, 2);
foreach (Vector3Int t in ring)
{
if (Random.Range(0f, 1f) < building.ring2Probability)
{
tilemap.SetTile(t, building.ring2Tile[Random.Range(0, building.ring2Tile.Length)]);
if (building.flipAllowed && Random.Range(0, 2) != 0)
{
Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 180f, 0f), Vector3.one);
tilemap.SetTransformMatrix(t, matrix);
}
}
}
}
}
}
private void CreateGrid(int column, int row)
{
HexagonalTileFactory tileFactory = new HexagonalTileFactory();
tileFactory.TileSize = _tileSize;
tileFactory.TileParent = gameObject;
tileFactory.TemplateTile = _tileTemplate.gameObject;
for (int columnIndex = 0; columnIndex < column; ++columnIndex)
{
for (int rowIndex = 0; rowIndex < row; ++rowIndex)
{
HexagonalTile tile = tileFactory.CreateTile(columnIndex, rowIndex);
if (tile == null)
{
continue;
}
tile.SetClickDelegate(HexagonalGridView.Instance.TileClickDelegate);
}
}
}
public HexagonalTile CreateTile(int columnIndex, int rowIndex)
{
GameObject newTileObject = NGUITools.AddChild(TileParent, TemplateTile);
if (newTileObject == null)
{
return(null);
}
HexagonalTile newTile = newTileObject.GetComponent <HexagonalTile>();
if (newTile == null)
{
return(null);
}
newTile.SetOffsetIndex(columnIndex, rowIndex);
newTile.SetPosition(columnIndex, rowIndex);
newTile.UpdateOffsetPosition(TileSize);
return(newTile);
}
public void TileClickDelegate(HexagonalTile clickTile)
{
if (clickTile == null)
{
return;
}
_firstSelectTileFlag = !_firstSelectTileFlag;
if (_firstSelectTileFlag)
{
ClearSelectTiles();
SetFirstSelectTile(clickTile);
}
else
{
SetSecondSelectTile(clickTile);
int selectedTileDistance = GetSelectedTilesDistance();
Debug.LogFormat("Selectd tiles distance : {0}", selectedTileDistance);
}
}
private void SetSecondSelectTile(HexagonalTile selectTile)
{
_secondSelectTile = selectTile;
_secondSelectTile.SetSelectImageActive(true);
}
private void SetFirstSelectTile(HexagonalTile selectTile)
{
_firstSelectTile = selectTile;
_firstSelectTile.SetSelectImageActive(true);
}
