private void ExcitedGroupMerge(GridAtmosphereComponent gridAtmosphere, ExcitedGroup ourGroup, ExcitedGroup otherGroup)
{
DebugTools.Assert(!ourGroup.Disposed, "Excited group is disposed!");
DebugTools.Assert(!otherGroup.Disposed, "Excited group is disposed!");
DebugTools.Assert(gridAtmosphere.ExcitedGroups.Contains(ourGroup), "Grid Atmosphere does not contain Excited Group!");
DebugTools.Assert(gridAtmosphere.ExcitedGroups.Contains(otherGroup), "Grid Atmosphere does not contain Excited Group!");
var ourSize = ourGroup.Tiles.Count;
var otherSize = otherGroup.Tiles.Count;
ExcitedGroup winner;
ExcitedGroup loser;
if (ourSize > otherSize)
{
winner = ourGroup;
loser = otherGroup;
}
else
{
winner = otherGroup;
loser = ourGroup;
}
foreach (var tile in loser.Tiles)
{
tile.ExcitedGroup = winner;
winner.Tiles.Add(tile);
}
loser.Tiles.Clear();
ExcitedGroupDispose(gridAtmosphere, loser);
ExcitedGroupResetCooldowns(winner);
}
private void ExcitedGroupRemoveTile(ExcitedGroup excitedGroup, TileAtmosphere tile)
{
DebugTools.Assert(!excitedGroup.Disposed, "Excited group is disposed!");
DebugTools.Assert(tile.ExcitedGroup == excitedGroup, "Tried to remove a tile from an excited group it's not present in!");
tile.ExcitedGroup = null;
excitedGroup.Tiles.Remove(tile);
}
private void ExcitedGroupAddTile(ExcitedGroup excitedGroup, TileAtmosphere tile)
{
DebugTools.Assert(!excitedGroup.Disposed, "Excited group is disposed!");
DebugTools.Assert(tile.ExcitedGroup == null, "Tried to add a tile to an excited group when it's already in another one!");
excitedGroup.Tiles.Add(tile);
tile.ExcitedGroup = excitedGroup;
ExcitedGroupResetCooldowns(excitedGroup);
}
private void ExcitedGroupDispose(GridAtmosphereComponent gridAtmosphere, ExcitedGroup excitedGroup)
{
if (excitedGroup.Disposed)
{
return;
}
DebugTools.Assert(gridAtmosphere.ExcitedGroups.Contains(excitedGroup), "Grid Atmosphere does not contain Excited Group!");
excitedGroup.Disposed = true;
gridAtmosphere.ExcitedGroups.Remove(excitedGroup);
ExcitedGroupDismantle(gridAtmosphere, excitedGroup, false);
}
private void ExcitedGroupDismantle(GridAtmosphereComponent gridAtmosphere, ExcitedGroup excitedGroup, bool unexcite = true)
{
foreach (var tile in excitedGroup.Tiles)
{
tile.ExcitedGroup = null;
if (!unexcite)
{
continue;
}
RemoveActiveTile(gridAtmosphere, tile);
}
excitedGroup.Tiles.Clear();
}
public override void RemoveExcitedGroup(ExcitedGroup excitedGroup)
{
}
public override void AddExcitedGroup(ExcitedGroup excitedGroup)
{
}
public void RemoveExcitedGroup(ExcitedGroup excitedGroup)
{
_excitedGroups.Remove(excitedGroup);
}
public void AddExcitedGroup(ExcitedGroup excitedGroup)
{
_excitedGroups.Add(excitedGroup);
}
private void ProcessCell(GridAtmosphereComponent gridAtmosphere, TileAtmosphere tile, int fireCount)
{
// Can't process a tile without air
if (tile.Air == null)
{
RemoveActiveTile(gridAtmosphere, tile);
return;
}
if (tile.ArchivedCycle < fireCount)
{
Archive(tile, fireCount);
}
tile.CurrentCycle = fireCount;
var adjacentTileLength = 0;
for (var i = 0; i < Atmospherics.Directions; i++)
{
var direction = (AtmosDirection)(1 << i);
if (tile.AdjacentBits.IsFlagSet(direction))
{
adjacentTileLength++;
}
}
for (var i = 0; i < Atmospherics.Directions; i++)
{
var direction = (AtmosDirection)(1 << i);
if (!tile.AdjacentBits.IsFlagSet(direction))
{
continue;
}
var enemyTile = tile.AdjacentTiles[i];
// If the tile is null or has no air, we don't do anything for it.
if (enemyTile?.Air == null)
{
continue;
}
if (fireCount <= enemyTile.CurrentCycle)
{
continue;
}
Archive(enemyTile, fireCount);
var shouldShareAir = false;
if (ExcitedGroups && tile.ExcitedGroup != null && enemyTile.ExcitedGroup != null)
{
if (tile.ExcitedGroup != enemyTile.ExcitedGroup)
{
ExcitedGroupMerge(gridAtmosphere, tile.ExcitedGroup, enemyTile.ExcitedGroup);
}
shouldShareAir = true;
}
else if (tile.Air !.Compare(enemyTile.Air !) != GasMixture.GasCompareResult.NoExchange)
{
if (!enemyTile.Excited)
{
AddActiveTile(gridAtmosphere, enemyTile);
}
if (ExcitedGroups)
{
var excitedGroup = tile.ExcitedGroup;
excitedGroup ??= enemyTile.ExcitedGroup;
if (excitedGroup == null)
{
excitedGroup = new ExcitedGroup();
gridAtmosphere.ExcitedGroups.Add(excitedGroup);
}
if (tile.ExcitedGroup == null)
{
ExcitedGroupAddTile(excitedGroup, tile);
}
if (enemyTile.ExcitedGroup == null)
{
ExcitedGroupAddTile(excitedGroup, enemyTile);
}
}
shouldShareAir = true;
}
if (shouldShareAir)
{
var difference = Share(tile.Air !, enemyTile.Air !, adjacentTileLength);
if (SpaceWind)
{
if (difference > 0)
{
ConsiderPressureDifference(gridAtmosphere, tile, enemyTile, difference);
}
else
{
ConsiderPressureDifference(gridAtmosphere, enemyTile, tile, -difference);
}
}
LastShareCheck(tile);
}
}
if (tile.Air != null)
{
React(tile.Air, tile);
}
InvalidateVisuals(tile.GridIndex, tile.GridIndices);
var remove = true;
if (tile.Air !.Temperature > Atmospherics.MinimumTemperatureStartSuperConduction)
{
if (ConsiderSuperconductivity(gridAtmosphere, tile, true))
{
remove = false;
}
}
if (ExcitedGroups && tile.ExcitedGroup == null && remove)
{
RemoveActiveTile(gridAtmosphere, tile);
}
}
private void ExcitedGroupSelfBreakdown(GridAtmosphereComponent gridAtmosphere, ExcitedGroup excitedGroup)
{
DebugTools.Assert(!excitedGroup.Disposed, "Excited group is disposed!");
DebugTools.Assert(gridAtmosphere.ExcitedGroups.Contains(excitedGroup), "Grid Atmosphere does not contain Excited Group!");
var combined = new GasMixture(Atmospherics.CellVolume);
var tileSize = excitedGroup.Tiles.Count;
if (excitedGroup.Disposed)
{
return;
}
if (tileSize == 0)
{
ExcitedGroupDispose(gridAtmosphere, excitedGroup);
return;
}
foreach (var tile in excitedGroup.Tiles)
{
if (tile?.Air == null)
{
continue;
}
Merge(combined, tile.Air);
if (!ExcitedGroupsSpaceIsAllConsuming || !tile.Air.Immutable)
{
continue;
}
combined.Clear();
break;
}
combined.Multiply(1 / (float)tileSize);
foreach (var tile in excitedGroup.Tiles)
{
if (tile?.Air == null)
{
continue;
}
tile.Air.CopyFromMutable(combined);
InvalidateVisuals(tile.GridIndex, tile.GridIndices);
}
excitedGroup.BreakdownCooldown = 0;
}
private void ExcitedGroupResetCooldowns(ExcitedGroup excitedGroup)
{
DebugTools.Assert(!excitedGroup.Disposed, "Excited group is disposed!");
excitedGroup.BreakdownCooldown = 0;
excitedGroup.DismantleCooldown = 0;
}