public override void Act(StateController controller)
{
entity = controller.entity as MovingEntity;
HashSet <TileProperties> visited = new HashSet <TileProperties>();
visited.Add(entity.Tile);
Queue <TileProperties> fringes = new Queue <TileProperties>();
fringes.Enqueue(entity.Tile);
while (fringes.Count > 0)
{
TileProperties previousTile = fringes.Dequeue();
TileProperties[] neighbors = previousTile.GetNeighbors();
for (int j = 0; j < neighbors.Length; j++)
{
TileProperties neighbor = neighbors[j];
if (neighbor && neighbor.Tile && !visited.Contains(neighbor))
{
if (terrains.Contains(neighbor.Tile.terrainType))
{
TryMoveToBiome(neighbor);
return;
}
else
{
fringes.Enqueue(neighbor);
}
visited.Add(neighbor);
}
}
}
}
public void UpdateTile(TileProperties tile)
{
CustomTile previousCustomTile = tile.Tile;
UpdateCustomTile(tile);
if (previousCustomTile != tile.Tile)
{
tile.ResetTile();
tile.SetAddon();
foreach (TileProperties neighbor in tile.GetNeighbors())
{
neighbor.ResetTile();
neighbor.SetBorders();
neighbor.PutRivers();
}
tile.SetBorders();
tile.PutRivers();
}
}
public void Compute()
{
//grid.Tilemap.RefreshAllTiles();
foreach (WindOrigin wo in WindManager.Instance.windOrigins)
{
wo.InitCorridor();
}
for (int i = 0; i < grid.tilesArray.GetLength(0); i++)
{
for (int j = 0; j < grid.tilesArray.GetLength(1); j++)
{
if (grid.tilesArray[i, j] != null)
{
grid.tilesArray[i, j].Tile = grid.Tilemap.GetTile(grid.tilesArray[i, j].Coordinates.OffsetCoordinates) as CustomTile;
grid.tilesArray[i, j].windDryness = 0;
grid.tilesArray[i, j].nextTilesInCorridor.Clear();
}
}
}
for (int i = 0; i < grid.tilesArray.GetLength(0); i++)
{
for (int j = 0; j < grid.tilesArray.GetLength(1); j++)
{
if (grid.tilesArray[i, j] != null)
{
grid.tilesArray[i, j].ResetRiver();
}
}
}
List <River> riverList = new List <River>();
for (int i = 0; i < grid.tilesArray.GetLength(0); i++)
{
for (int j = 0; j < grid.tilesArray.GetLength(1); j++)
{
TileProperties prop = grid.tilesArray[i, j];
if (prop != null)
{
if (prop.Tile && prop.Tile.riverSource)
{
River R = new River(grid.tilesArray[i, j].Coordinates, prop.Tile.riverDirection, prop.Tile.riverCounterClockwise, riverForce);
riverList.Add(R);
}
}
}
}
bool extend;
do
{
extend = false;
foreach (River r in riverList)
{
if (r.force > 0)
{
r.ExtendRiver(grid);
extend = true;
}
}
} while (extend);
foreach (River r in riverList)
{
r.PutLac(grid);
}
for (int i = 0; i < grid.tilesArray.GetLength(0); i++)
{
for (int j = 0; j < grid.tilesArray.GetLength(1); j++)
{
TileProperties prop = grid.tilesArray[i, j];
if (prop != null && (prop.asLake || prop.asRiver))
{
prop.humidity = riverRadius;
//this.SetColor(prop.Coordinates.OffsetCoordinates, Color.red);
}
}
}
for (int b = 0; b < riverRadius; b++)
{
for (int i = 0; i < grid.tilesArray.GetLength(0); i++)
{
for (int j = 0; j < grid.tilesArray.GetLength(1); j++)
{
TileProperties prop = grid.tilesArray[i, j];
if (prop != null)
{
foreach (var N in prop.GetNeighbors())
{
if (!N)
{
continue;
}
N.humidity = Mathf.Max(prop.humidity - 1, N.humidity);
}
}
}
}
}
ComputeDryness();
UpdateTiles();
}
public static Stack <TileProperties> Path(TileProperties begin, TileProperties end, List <CustomTile> availableTiles = null, Movable movable = null)
{
if (end == null)
{
return(null);
}
PriorityQueue <TileProperties> frontier = new PriorityQueue <TileProperties>();
frontier.Enqueue(begin, 0);
Dictionary <TileProperties, TileProperties> cameFrom = new Dictionary <TileProperties, TileProperties>();
Dictionary <TileProperties, double> costSoFar = new Dictionary <TileProperties, double>();
cameFrom.Add(begin, begin);
costSoFar.Add(begin, 0);
while (frontier.Count != 0)
{
TileProperties current = frontier.Dequeue();
if (current == end)
{
break;
}
TileProperties[] neighbors = current.GetNeighbors();
foreach (TileProperties next in neighbors)
{
if (!next || !next.Tile || next.whirlwind)
{
continue;
}
if (availableTiles != null && !availableTiles.Contains(next.Tile))
{
continue;
}
if (movable && next != end && ((next.movingEntity && !movable.canPassAboveEntities) || (next.asLake && !movable.canPassAboveLakes) ||
(next.Tile.riverSource && !movable.canPassAboveMontains) || (next.windOrigin && !movable.canPassAboveWindOrigins)))
{
continue;
}
else if (!movable && ((next.currentMovable && next != end) || next.asLake || next.Tile.riverSource))
{
continue;
}
double newCost = costSoFar[current] + NextCost(current, next);
if (!costSoFar.ContainsKey(next) || newCost < costSoFar[next])
{
costSoFar[next] = newCost;
double priority = newCost + Heuristic(next, end);
frontier.Enqueue(next, priority);
cameFrom[next] = current;
}
}
}
// Convert the cameFrom dictionary to a stack that contains the path;
Stack <TileProperties> path = new Stack <TileProperties>();
if (!cameFrom.ContainsKey(end))
{
return(null);
}
path.Push(end);
TileProperties currentTile = cameFrom[end];
path.Push(currentTile);
while (currentTile != begin)
{
currentTile = cameFrom[currentTile];
path.Push(currentTile);
}
return(path);
}
