public BaseTileData RegisterRandomFloodableTile(WaterCluster cluster)
{
BaseTileData tile = GetRandomFloodableTile(cluster);
AddPossibleFloodTile(cluster, tile);
return(tile);
}
public void CreateClusters(IEnumerable <BaseTileData> waterTiles)
{
if (clusters != null)
{
clusters.Clear();
}
clusters = new List <WaterCluster>();
_tilesChecked = 0;
_nextClusterId = 0;
// Reset cluster flags, as they are our reference for the algorithm
foreach (BaseTileData tile in waterTiles)
{
((WaterTile)tile.terrainTile).clusterFlag = false;
}
foreach (BaseTileData tile in waterTiles)
{
if (!((WaterTile)tile.terrainTile).clusterFlag)
{
_nextClusterId++;
WaterCluster cluster = new WaterCluster(_nextClusterId);
FlagTileAndPropagate(tile, cluster);
cluster.RecountFloodLevel();
clusters.Add(cluster);
}
}
}
public BaseTileData UsePossibleFloodTile(WaterCluster cluster)
{
if (!_possibleFloodTiles.ContainsKey(cluster))
{
throw new NoFloodableTileForClusterException();
}
_possibleFloodTiles.TryGetValue(cluster, out Stack <BaseTileData> associatedTiles);
return(associatedTiles.Pop());
}
public BaseTileData GetRandomFloodableTile(WaterCluster cluster)
{
IEnumerable <BaseTileData> floodableTiles = GetFloodableTiles(cluster);
if (floodableTiles.Any())
{
int selectedIndex = Alea.GetInt(0, floodableTiles.Count());
return(floodableTiles.ElementAt(selectedIndex));
}
return(null);
}
public WaterCluster GetClusterForTile(BaseTileData tile)
{
WaterCluster res = null;
foreach (WaterCluster cluster in clusters)
{
if (cluster.tiles.Contains(tile))
{
res = cluster;
}
}
return(res);
}
public List <BaseTileData> GetPumpedTilesForCluster(WaterCluster cluster)
{
List <BaseTileData> pumpedTiles = GetPumpedTiles();
List <BaseTileData> clusterPumpedTiles = new List <BaseTileData>();
foreach (BaseTileData tile in pumpedTiles)
{
if (cluster.ContainsTile(tile))
{
clusterPumpedTiles.Add(tile);
}
}
return(clusterPumpedTiles);
}
public void AddPossibleFloodTile(WaterCluster cluster, BaseTileData tile)
{
if (_possibleFloodTiles.ContainsKey(cluster))
{
_possibleFloodTiles.TryGetValue(cluster, out Stack <BaseTileData> associatedTiles);
associatedTiles.Push(tile);
}
else
{
Stack <BaseTileData> associatedTiles = new Stack <BaseTileData>();
associatedTiles.Push(tile);
_possibleFloodTiles.Add(cluster, associatedTiles);
}
}
public IEnumerable <BaseTileData> GetFloodableTiles(WaterCluster cluster)
{
List <BaseTileData> possibleNeighbours = new List <BaseTileData>();
foreach (BaseTileData tile in cluster.tiles)
{
IEnumerable <BaseTileData> currentNeighbours = TilesDataManager.Instance.GetTilesDirectlyAroundTile(tile, true);
foreach (BaseTileData neighbour in currentNeighbours)
{
if (!possibleNeighbours.Contains(neighbour) && neighbour.terrainTile.terrainData.canBeFlooded)
{
possibleNeighbours.Add(neighbour);
}
}
}
return(possibleNeighbours);
}
private void FlagTileAndPropagate(BaseTileData tile, WaterCluster cluster)
{
// Basic security
_tilesChecked++;
if (_tilesChecked >= 1000)
{
throw new AlgorithmTakesTooLongException();
}
// Flag current tile and add it to the cluster
((WaterTile)tile.terrainTile).clusterFlag = true;
cluster.AddTile(tile);
// Check neighbours to flag
foreach (BaseTileData neighbourTile in GetDirectWaterNeighbours(tile, true))
{
if (!((WaterTile)neighbourTile.terrainTile).clusterFlag)
{
FlagTileAndPropagate(neighbourTile, cluster);
}
}
}
public FloodClusterCommand(WaterCluster cluster)
{
_cluster = cluster;
}
public PumpWaterClusterCommand(WaterCluster cluster)
{
_cluster = cluster;
}
public FloodTileCommand(WaterCluster cluster, BaseTileData tile)
{
_cluster = cluster;
_originTile = tile;
}
public WaterClusterBalanceCommand(WaterCluster cluster)
{
_cluster = cluster;
}
public WaterClusterRemoveFloodCommand(WaterCluster cluster, int amount)
{
_cluster = cluster;
_amount = amount;
_balanceCommand = new WaterClusterBalanceCommand(cluster);
}
