protected override void WriteObject(AssetsWriter writer)
{
LocalRotation.Write(writer);
LocalPosition.Write(writer);
LocalScale.Write(writer);
writer.WriteArrayOf(Children, (x, y) => x.Write(y));
Father.Write(writer);
}
public override void Write(AssetsWriter writer)
{
base.WriteBase(writer);
LocalRotation.Write(writer);
LocalPosition.Write(writer);
LocalScale.Write(writer);
writer.WriteArrayOf(Children, x => x.WritePtr(writer));
Father.WritePtr(writer);
}
protected Rectangle GetDefaultRect(Rectangle parent)
{
Rectangle drawRect = new Rectangle();
if (Size.HasFlag(DrawingSize.XMin))
{
drawRect.Width = (int)MinimumSize.X;
}
else if (Size.HasFlag(DrawingSize.XMax))
{
drawRect.Width = parent.Size.X;
}
if (Size.HasFlag(DrawingSize.YMin))
{
drawRect.Height = (int)MinimumSize.Y;
}
else if (Size.HasFlag(DrawingSize.YMax))
{
drawRect.Height = parent.Size.Y;
}
if (drawRect.Width > MaximumSize.X && MaximumSize.X != -1)
{
drawRect.Width = (int)MaximumSize.X;
}
if (drawRect.Height > MaximumSize.Y && MaximumSize.Y != -1)
{
drawRect.Height = (int)MaximumSize.Y;
}
if (ScalingMethod == ScalingMethod.KeepRatio)
{
if (drawRect.Width * ratio > MaximumSize.Y)
{
drawRect.Width = (int)(MaximumSize.Y / ratio);
}
drawRect.Height = (int)(drawRect.Width * ratio);
}
if (drawRect.Width < MinimumSize.X && MinimumSize.X != -1)
{
drawRect.Width = (int)MinimumSize.X;
}
if (drawRect.Height < MinimumSize.Y && MinimumSize.Y != -1)
{
drawRect.Height = (int)MinimumSize.Y;
}
drawRect.Location = LocalPosition.ToPoint() + parent.Location;
drawRect.Location += Offset.ToPoint();
drawRect.Location += (drawRect.Size.ToVector2() * -Origin).ToPoint(); // Origin
return(drawRect);
}
public WorldPosition(int x, int y, int z)
{
var chunkX = Mathf.FloorToInt((float)x / ChunkSize);
var chunkY = Mathf.FloorToInt((float)y / ChunkSize);
var chunkZ = Mathf.FloorToInt((float)z / ChunkSize);
chunkPosition = new ChunkPosition(chunkX, chunkY, chunkZ);
localPosition = new LocalPosition((uint)(x - chunkX * ChunkSize),
(uint)(y - chunkY * ChunkSize), (uint)(z - chunkX * ChunkSize));
}
public override void Read(AssetReader reader)
{
base.Read(reader);
LocalRotation.Read(reader);
LocalPosition.Read(reader);
LocalScale.Read(reader);
m_children = reader.ReadArray <PPtr <Transform> >();
Father.Read(reader);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
LocalRotation.Read(stream);
LocalPosition.Read(stream);
LocalScale.Read(stream);
m_children = stream.ReadArray <PPtr <Transform> >();
Father.Read(stream);
}
public override void Read(EndianStream stream)
{
base.Read(stream);
LocalRotation.Read(stream);
LocalPosition.Read(stream);
LocalScale.Read(stream);
m_children = stream.ReadArray(() => new PPtr <Transform>(AssetsFile));
Father.Read(stream);
}
public LocalPosition Add(LocalPosition other, out ChunkPosition offset)
{
var totalX = x + other.x;
var totalY = y + other.y;
var totalZ = z + other.z;
offset = new ChunkPosition((int)(totalX / ChunkSize),
(int)(totalY / ChunkSize), (int)(totalZ / ChunkSize));
return(new LocalPosition(totalX % ChunkSize, totalY % ChunkSize, totalZ % ChunkSize));
}
private Node[] GetCurrentTeamPosition(List <Unit> team)
{
Node[] teamPosition = new Node[team.Count];
for (int i = 0; i < team.Count; ++i)
{
LocalPosition localPos = PositionConverter.ToLocalCoordinates(team[i].worldPosition);
teamPosition[i] = BoardManager.Instance.map.graph[localPos.x, localPos.y];
}
return(teamPosition);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add("m_LocalRotation", LocalRotation.ExportYAML(container));
node.Add("m_LocalPosition", LocalPosition.ExportYAML(container));
node.Add("m_LocalScale", LocalScale.ExportYAML(container));
node.Add("m_Children", Children.ExportYAML(container));
node.Add("m_Father", Father.ExportYAML(container));
node.Add("m_RootOrder", GetSiblingIndex());
node.Add("m_LocalEulerAnglesHint", LocalRotation.ToEuler().ExportYAML(container));
return(node);
}
private void OnMouseUp()
{
LocalPosition clickedTileLocalPos = PositionConverter.ToLocalCoordinates(new WorldPosition(tileX, 0, tileY));
Node clickedTtile = BoardManager.Instance.map.graph[clickedTileLocalPos.x, clickedTileLocalPos.y];
if (BoardManager.selectedUnit != null && BoardManager.Instance.isAvailableClickedTile(clickedTtile) && !GameManager.isGameOver)
{
BoardManager.Instance.GeneratePathTo(tileX, tileY);
BoardManager.selectedUnit.MoveToEnterTile();
Human.isDoUnit = true;
Unit.isHumanMakeTurn = true;
}
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add(LocalRotationName, LocalRotation.ExportYAML(container));
node.Add(LocalPositionName, LocalPosition.ExportYAML(container));
node.Add(LocalScaleName, LocalScale.ExportYAML(container));
node.Add(ChildrenName, Children.ExportYAML(container));
node.Add(FatherName, Father.ExportYAML(container));
node.Add(RootOrderName, GetRootOrder(container.Version, container.Flags));
node.Add(LocalEulerAnglesHintName, GetLocalEulerAnglesHint(container.Version, container.Flags).ExportYAML(container));
return(node);
}
void CreateTileMap()
{
const int mountainLimit = 6;
int countMountainTile = 0;
System.Random rand = new System.Random();
tiles = new int[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
#region get tile type
TileType tt;
int tileType = 0;
if (x > width / 3)
{
tileType = rand.Next(2);
}
if (tileType == 1 && countMountainTile != mountainLimit)
{
tt = tileTypes[1];
++countMountainTile;
}
else
{
tt = tileTypes[0];
}
#endregion
LocalPosition tilePos = new LocalPosition(x, y);
Transform tile = Instantiate(tt.tileVisualPrefab.transform) as Transform;
tile.position = PositionConverter.ToWorldCoordinates(tilePos).ToVector3();
tile.parent = transform;
tile.name = "Hexagon" + tilePos.x + "|" + tilePos.y;
ClickableAvailableTile ct;
if (tile.GetComponent <ClickableAvailableTile>() != null)
{
ct = tile.GetComponent <ClickableAvailableTile>();
ct.tileX = tile.position.x;
ct.tileY = tile.position.z;
}
tiles[x, y] = TileType.GetTileTypeByTileName(tt.name);
}
}
}
protected override void OnUpdate()
{
while (m_Group.Length != 0)
{
var spawner = m_Group.Spawner[0];
var sourceEntity = m_Group.Entity[0];
var center = m_Group.Position[0].Value;
var entities = new NativeArray <Entity>(spawner.count, Allocator.Temp);
EntityManager.Instantiate(spawner.prefab, entities);
var positions = new NativeArray <float3>(spawner.count, Allocator.Temp);
if (spawner.spawnLocal)
{
GeneratePoints.RandomPointsOnCircle(new float3(), spawner.radius, ref positions);
for (int i = 0; i < spawner.count; i++)
{
var position = new LocalPosition
{
Value = positions[i]
};
EntityManager.SetComponentData(entities[i], position);
EntityManager.AddComponentData(entities[i], new TransformParent {
Value = sourceEntity
});
}
}
else
{
GeneratePoints.RandomPointsOnCircle(center, spawner.radius, ref positions);
for (int i = 0; i < spawner.count; i++)
{
var position = new Position
{
Value = positions[i]
};
EntityManager.SetComponentData(entities[i], position);
}
}
entities.Dispose();
positions.Dispose();
EntityManager.RemoveComponent <SpawnRandomCircle>(sourceEntity);
// Instantiate & AddComponent & RemoveComponent calls invalidate the injected groups,
// so before we get to the next spawner we have to reinject them
UpdateInjectedComponentGroups();
}
}
public static WorldPosition ToWorldCoordinates(LocalPosition localPosition)
{
float offset = 0;
if (localPosition.y % 2 != 0)
{
offset = TileMap.hexWidth / 2;
}
float x = TileMap.startPos.x + localPosition.x * TileMap.hexWidth + offset;
float z = TileMap.startPos.z - localPosition.y * TileMap.hexHeight * 0.75f;
return(new WorldPosition(x, 0, z));
}
private static string GetLocalPositionLabel(LocalPosition lp)
{
switch (lp)
{
case LocalPosition.LpnRepresentative:
return("LPN Rep.");
case LocalPosition.ShopSteward:
return("Shop Steward");
default:
return("Missing Label");
}
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
TransformLayout layout = container.Layout.Transform;
node.Add(layout.LocalRotationName, LocalRotation.ExportYAML(container));
node.Add(layout.LocalPositionName, LocalPosition.ExportYAML(container));
node.Add(layout.LocalScaleName, LocalScale.ExportYAML(container));
node.Add(layout.ChildrenName, Children.ExportYAML(container));
node.Add(layout.FatherName, Father.ExportYAML(container));
node.Add(layout.RootOrderName, RootOrder);
node.Add(layout.LocalEulerAnglesHintName, LocalEulerAnglesHint.ExportYAML(container));
return(node);
}
protected override void OnUpdate()
{
while (m_Group.Length != 0)
{
var spawner = m_Group.Spawner[0];
var sourceEntity = m_Group.Entity[0];
//var center = m_Group.Position[0].Value;
var entities = new NativeArray <Entity>(spawner.count, Allocator.Temp);
EntityManager.Instantiate(spawner.prefab, entities);
var positions = new NativeArray <float3>(spawner.count, Allocator.Temp);
for (int i = 0; i < spawner.count; i++)
{
var position = new LocalPosition
{
Value = positions[i] + new float3
{
x = Random.Range(-10f, 10f),
y = Random.Range(-10f, 10f),
z = Random.Range(-10f, 10f)
}
};
EntityManager.SetComponentData(entities[i], position);
EntityManager.AddComponentData(entities[i], new RotationTestSpeed {
Value = Random.Range(0.5f, 3f)
});
EntityManager.AddComponentData(entities[i], new TestId {
Value = i
});
EntityManager.AddComponentData(entities[i], new TransformParent {
Value = sourceEntity
});
}
entities.Dispose();
positions.Dispose();
EntityManager.RemoveComponent <SpawnTest>(sourceEntity);
// Instantiate & AddComponent & RemoveComponent calls invalidate the injected groups,
// so before we get to the next spawner we have to reinject them
UpdateInjectedComponentGroups();
}
}
public LocalPosition Subtract(LocalPosition other, out ChunkPosition offset)
{
uint totalX;
uint totalY;
uint totalZ;
int chunkX;
int chunkY;
int chunkZ;
if (x > other.x)
{
totalX = x - other.x;
chunkX = (int)(totalX / ChunkSize);
}
else
{
totalX = other.x - x;
chunkX = -(int)(totalX / ChunkSize);
}
if (y > other.y)
{
totalY = y - other.y;
chunkY = (int)(totalY / ChunkSize);
}
else
{
totalY = other.y - y;
chunkY = -(int)(totalY / ChunkSize);
}
if (z > other.z)
{
totalZ = z - other.z;
chunkZ = (int)(totalZ / ChunkSize);
}
else
{
totalZ = other.z - z;
chunkZ = -(int)(totalZ / ChunkSize);
}
offset = new ChunkPosition(chunkX, chunkY, chunkZ);
return(new LocalPosition(totalX % ChunkSize, totalY % ChunkSize, totalZ & ChunkSize));
}
private List <Node> GetAllAvailableUnitMoves(Unit unit)
{
BoardManager.selectedUnit = unit;
List <Node> moves = new List <Node>();
LocalPosition localPos = PositionConverter.ToLocalCoordinates(unit.worldPosition);
BoardManager.Instance.GetAvailableMovementTiles(moves, BoardManager.Instance.map.graph[localPos.x, localPos.y]);
List <Unit> availableHumanUnitsForAttack = BoardManager.Instance.GetAvailableHumanUnitsForAttack();
foreach (var item in availableHumanUnitsForAttack)
{
moves.Add(BoardManager.Instance.map.graph[item.localPosition.x, item.localPosition.y]);
}
return(moves);
}
public void UpdateGlobalsFromParent()
{
if (parent == null)
{
Position = LocalPosition;
Orientation = LocalOrientation;
}
else
{
Position = parent.Position + LocalPosition.Transform(Parent.Orientation);
Orientation = parent.Orientation * LocalOrientation;
}
foreach (var child in Children)
{
child.UpdateGlobalsFromParent();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
LocalRotation.Read(reader);
LocalPosition.Read(reader);
LocalScale.Read(reader);
Children = reader.ReadAssetArray <PPtr <Transform> >();
Father.Read(reader);
#if UNIVERSAL
if (HasRootOrder(reader.Version, reader.Flags))
{
RootOrder = reader.ReadInt32();
}
if (HasLocalEulerAnglesHint(reader.Version, reader.Flags))
{
LocalEulerAnglesHint.Read(reader);
}
#endif
}
void InstantiateFromArray(NativeArray <Entity> prefabs, float xCoord, float yCoord, Entity parent)
{
// Create a random index for the array.
int randomIndex = Random.Range(0, prefabs.Length);
var entity = EntityManager.Instantiate(prefabs[randomIndex]);
var position = new LocalPosition
{
Value = new float3(xCoord, 0.0f, yCoord)
};
EntityManager.SetComponentData(entity, position);
var transformParent = new TransformParent
{
Value = parent
};
EntityManager.SetComponentData(entity, transformParent);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
LocalRotation.Write(writer);
LocalPosition.Write(writer);
LocalScale.Write(writer);
Children.Write(writer);
Father.Write(writer);
#if UNIVERSAL
TransformLayout layout = writer.Layout.Transform;
if (layout.HasRootOrder)
{
writer.Write(RootOrder);
}
if (layout.HasLocalEulerAnglesHint)
{
LocalEulerAnglesHint.Write(writer);
}
#endif
}
public override void Read(AssetReader reader)
{
base.Read(reader);
LocalRotation.Read(reader);
LocalPosition.Read(reader);
LocalScale.Read(reader);
Children = reader.ReadAssetArray <PPtr <Transform> >();
Father.Read(reader);
#if UNIVERSAL
TransformLayout layout = reader.Layout.Transform;
if (layout.HasRootOrder)
{
RootOrder = reader.ReadInt32();
}
if (layout.HasLocalEulerAnglesHint)
{
LocalEulerAnglesHint.Read(reader);
}
#endif
}
public void Update()
{
if (toInitialize?.Count > 0)
{
for (int index = 0; index < toInitialize.Count; index++)
{
var cmpt = toInitialize[index];
cmpt.InitializeComponent();
}
toInitialize.Clear();
}
if (isUpdateEnabled)
{
for (int index = 0; index < components.Count; index++)
{
var component = components[index];
if (component.Enabled)
{
component.UpdateComponent();
}
}
}
if (isUpdateEnabled && !IsStatic)
{
UpdateSpeculativePosition();
}
else
{
SpeculativePosition = LocalPosition.ToVector2();
}
if (children != null)
{
updateChildren();
}
}
public void SelectAvailableTile()
{
LocalPosition unitPosition = PositionConverter.ToLocalCoordinates(selectedUnit.worldPosition);
selectedUnit.availableMovementTiles = new List <Node>();
Node currentTile = map.graph[unitPosition.x, unitPosition.y];
GetAvailableMovementTiles(selectedUnit.availableMovementTiles, currentTile);
foreach (var item in selectedUnit.availableMovementTiles)
{
Collider[] colliders;
WorldPosition tileWorldPos = PositionConverter.ToWorldCoordinates(new LocalPosition(item.x, item.y));
colliders = Physics.OverlapSphere(tileWorldPos.ToVector3(), 0.125f /*Radius*/);
if (colliders.Length >= 1)
{
foreach (var collider in colliders)
{
var go = collider.gameObject;
if (go.name.StartsWith("Hexagon"))
{
if (map.tiles[item.x, item.y] != (int)TileTypes.SWAMP)
{
selectedUnit.startColor = go.GetComponent <Renderer>().material.GetColor("_Color");
selectedUnit.availableTileColor = selectedUnit.startColor;
//TODO: think about other variant of colorized tile
selectedUnit.availableTileColor.g = 0.6f;
selectedUnit.availableTileColor.b = 0.4f;
GameObjectHighlighter.Select(selectedUnit.startColor, selectedUnit.availableTileColor, go.GetComponent <Renderer>());
}
}
}
}
}
}
//todo: think about signature
public void GetAvailableMovementTiles(List <Node> availableMovementTiles, Node startPos)
{
int maxDepth = selectedUnit.distance;
int currentDepth = 0;
int elementsToDepthIncrease = 1;
int nextElementsToDepthIncrease = 0;
Queue <Node> burningTiles = new Queue <Node>();
burningTiles.Enqueue(startPos);
List <Node> visitedTiles = new List <Node>();
visitedTiles.Add(startPos);
// check other player units pos
foreach (var item in Instance.playerUnits)
{
LocalPosition unitPosition = PositionConverter.ToLocalCoordinates(item.worldPosition);
Node currentTileWithUnit = map.graph[unitPosition.x, unitPosition.y];
visitedTiles.Add(currentTileWithUnit);
}
// check other AI units pos
foreach (var item in Instance.enemyUnits)
{
LocalPosition unitPosition = PositionConverter.ToLocalCoordinates(item.worldPosition);
Node currentTileWithUnit = map.graph[unitPosition.x, unitPosition.y];
visitedTiles.Add(currentTileWithUnit);
}
while (burningTiles.Count != 0)
{
Node currentVertex = burningTiles.Dequeue();
foreach (var item in currentVertex.neighbours)
{
if (!visitedTiles.Contains(item) && map.tiles[item.x, item.y] != (int)TileTypes.SWAMP)
{
++nextElementsToDepthIncrease;
}
}
if (--elementsToDepthIncrease == 0)
{
elementsToDepthIncrease = nextElementsToDepthIncrease;
nextElementsToDepthIncrease = 0;
++currentDepth;
}
for (int i = 0; i < currentVertex.neighbours.Count; ++i)
{
Node tile = currentVertex.neighbours[i];
if ((!visitedTiles.Contains(tile) && map.tiles[tile.x, tile.y] != 1 /*mountain*/))
{
visitedTiles.Add(tile);
burningTiles.Enqueue(tile);
availableMovementTiles.Add(tile);
}
}
if (currentDepth == maxDepth)
{
return;
}
}
}
public void GeneratePathToEnemy(Unit enemy)
{
selectedUnit.currentPathToEnemy = null;
// check the neighborhood of units
if (selectedUnit.DistanceTo(enemy) == 1)
{
Node enemyTile = map.graph[enemy.localPosition.x, enemy.localPosition.y];
List <Node> enemyTileNeighbours = enemyTile.neighbours;
Node selectedUnitTile = map.graph[selectedUnit.localPosition.x, selectedUnit.localPosition.y];
foreach (var item in enemyTileNeighbours)
{
if (selectedUnitTile.DistanceBetweenNode(item) == 1 &&
map.tiles[item.x, item.y] != (int)TileTypes.SWAMP &&
!isUnitOccupiedNode(item))
{
currentPathToEnemy = new List <Node>();
currentPathToEnemy.Add(item);
selectedUnit.currentPathToEnemy = currentPathToEnemy;
return;
}
}
}
Dictionary <Node, float> dist = new Dictionary <Node, float>();
Dictionary <Node, Node> prev = new Dictionary <Node, Node>();
List <Node> unvisited = new List <Node>();
LocalPosition sourceLocalPos = PositionConverter.ToLocalCoordinates(selectedUnit.worldPosition);
LocalPosition targetLocalPos = PositionConverter.ToLocalCoordinates(enemy.worldPosition);
Node source = map.graph[sourceLocalPos.x, sourceLocalPos.y];
Node target = map.graph[targetLocalPos.x, targetLocalPos.y];
Node currentUnitPos = map.graph[selectedUnit.localPosition.x, selectedUnit.localPosition.y];
if (selectedUnit.availableMovementTiles == null)
{
selectedUnit.availableMovementTiles = new List <Node>();
}
GetAvailableMovementTiles(selectedUnit.availableMovementTiles, currentUnitPos);
if (selectedUnit.CanAttack(enemy))
{
dist[source] = 0;
prev[source] = null;
foreach (var vertex in map.graph)
{
if (vertex != source)
{
dist[vertex] = Mathf.Infinity;
prev[vertex] = null;
}
unvisited.Add(vertex);
}
while (unvisited.Count > 0)
{
Node u = null;
foreach (var possibleU in unvisited)
{
if (u == null || dist[u] > dist[possibleU])
{
u = possibleU;
}
}
if (u == target)
{
break;
}
unvisited.Remove(u);
foreach (var v in u.neighbours)
{
if (selectedUnit.availableMovementTiles.Contains(v) || (v.x == enemy.localPosition.x && v.y == enemy.localPosition.y))
{
float alt = dist[u] + u.DistanceTo(v); //without calc tile cost
if (alt < dist[v])
{
dist[v] = alt;
prev[v] = u;
}
}
}
}
if (prev[target] == null)
{
//No route between source and target
return;
}
else
{
currentPathToEnemy = new List <Node>();
Node currentTile = target;
while (currentTile != null)
{
currentPathToEnemy.Add(currentTile);
currentTile = prev[currentTile];
}
currentPathToEnemy.Reverse();
currentPathToEnemy.RemoveAt(currentPathToEnemy.Count - 1);
selectedUnit.currentPathToEnemy = currentPathToEnemy;
}
}
}
public void GeneratePathTo(float x, float z)
{
selectedUnit.currentPath = null;
Dictionary <Node, float> dist = new Dictionary <Node, float>();
Dictionary <Node, Node> prev = new Dictionary <Node, Node>();
List <Node> unvisited = new List <Node>();
LocalPosition sourceLocalPos = PositionConverter.ToLocalCoordinates(selectedUnit.worldPosition);
LocalPosition targetLocalPos = PositionConverter.ToLocalCoordinates(new WorldPosition(x, 0, z));
Node source = map.graph[sourceLocalPos.x, sourceLocalPos.y];
Node target = map.graph[targetLocalPos.x, targetLocalPos.y];
if (selectedUnit.availableMovementTiles == null)
{
selectedUnit.availableMovementTiles = new List <Node>();
Node currentTile = map.graph[selectedUnit.localPosition.x, selectedUnit.localPosition.y];
GetAvailableMovementTiles(selectedUnit.availableMovementTiles, currentTile);
}
if (selectedUnit.availableMovementTiles.Contains(target))
{
dist[source] = 0;
prev[source] = null;
foreach (var vertex in map.graph)
{
if (vertex != source)
{
dist[vertex] = Mathf.Infinity;
prev[vertex] = null;
}
unvisited.Add(vertex);
}
while (unvisited.Count > 0)
{
Node u = null;
foreach (var possibleU in unvisited)
{
if (u == null || dist[u] > dist[possibleU])
{
u = possibleU;
}
}
if (u == target)
{
break;
}
unvisited.Remove(u);
foreach (var v in u.neighbours)
{
if (selectedUnit.availableMovementTiles.Contains(v))
{
//float alt = dist[u] + u.DistanceTo(v); //without calc tile cost
float alt = dist[u] + map.CostToEnterTile(v.x, v.y);
if (alt < dist[v])
{
dist[v] = alt;
prev[v] = u;
}
}
}
}
if (prev[target] == null)
{
//No route between source and target
return;
}
else
{
currentPath = new List <Node>();
Node currentTile = target;
while (currentTile != null)
{
currentPath.Add(currentTile);
currentTile = prev[currentTile];
}
currentPath.Reverse();
selectedUnit.currentPath = currentPath;
}
}
}
