{
[Dependency] private readonly AtmosphereSystem _atmosphere = default!;
[Dependency] private readonly IMapManager _map = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
if (air.Pressure >= intake.Pressure)
return;
- var environment = _atmosphere.GetContainingMixture(uid, true, true);
+ var environment = _atmosphere.GetContainingMixture(uid, args.Grid, args.Map, true, true);
// nothing to intake from
if (environment == null)
return;
var oxygen = air.GetMoles(filter.Oxygen) / air.TotalMoles;
var gases = oxygen >= filter.TargetOxygen ? filter.Gases : filter.OverflowGases;
- var coordinates = Transform(uid).MapPosition;
GasMixture? destination = null;
- if (_map.TryFindGridAt(coordinates, out _, out var grid))
+ if (args.Grid is {} grid)
{
- var tile = grid.GetTileRef(coordinates);
- destination = _atmosphere.GetTileMixture(tile.GridUid, null, tile.GridIndices, true);
+ var position = _transform.GetGridTilePositionOrDefault(uid);
+ destination = _atmosphere.GetTileMixture(grid, args.Map, position, true);
}
if (destination != null)
/// <summary>
/// Event that tries to query the mixture a certain entity is exposed to.
+ /// This is mainly intended for use with entities inside of containers.
+ /// This event is not raised for entities that are directly parented to the grid.
/// </summary>
[ByRefEvent]
public struct AtmosExposedGetAirEvent
/// <summary>
/// The entity we want to query this for.
/// </summary>
- public readonly EntityUid Entity;
+ public readonly Entity<TransformComponent> Entity;
/// <summary>
/// The mixture that the entity is exposed to. Output parameter.
public GasMixture? Gas = null;
/// <summary>
- /// Whether to invalidate the mixture, if possible.
+ /// Whether to excite the mixture, if possible.
/// </summary>
- public bool Invalidate = false;
+ public readonly bool Excite = false;
/// <summary>
/// Whether this event has been handled or not.
/// </summary>
public bool Handled = false;
- public AtmosExposedGetAirEvent(EntityUid entity, bool invalidate = false)
+ public AtmosExposedGetAirEvent(Entity<TransformComponent> entity, bool excite = false)
{
Entity = entity;
- Invalidate = invalidate;
+ Excite = excite;
}
}
}
using Content.Server.Atmos.Reactions;
using Content.Server.NodeContainer.NodeGroups;
using Content.Shared.Atmos;
+using Content.Shared.Atmos.Components;
using Robust.Shared.Map.Components;
using Robust.Shared.Utility;
public partial class AtmosphereSystem
{
- public GasMixture? GetContainingMixture(EntityUid uid, bool ignoreExposed = false, bool excite = false, TransformComponent? transform = null)
+ public GasMixture? GetContainingMixture(Entity<TransformComponent?> ent, bool ignoreExposed = false, bool excite = false)
{
- if (!ignoreExposed)
- {
- // Used for things like disposals/cryo to change which air people are exposed to.
- var ev = new AtmosExposedGetAirEvent(uid, excite);
-
- // Give the entity itself a chance to handle this.
- RaiseLocalEvent(uid, ref ev, false);
-
- if (ev.Handled)
- return ev.Gas;
+ if (!Resolve(ent, ref ent.Comp))
+ return null;
- // We need to get the parent now, so we need the transform... If the parent is invalid, we can't do much else.
- if(!Resolve(uid, ref transform) || !transform.ParentUid.IsValid() || transform.MapUid == null)
- return GetTileMixture(null, null, Vector2i.Zero, excite);
+ return GetContainingMixture(ent, ent.Comp.GridUid, ent.Comp.MapUid, ignoreExposed, excite);
+ }
- // Give the parent entity a chance to handle the event...
- RaiseLocalEvent(transform.ParentUid, ref ev, false);
+ public GasMixture? GetContainingMixture(
+ Entity<TransformComponent?> ent,
+ Entity<GridAtmosphereComponent?, GasTileOverlayComponent?>? grid,
+ Entity<MapAtmosphereComponent?>? map,
+ bool ignoreExposed = false,
+ bool excite = false)
+ {
+ if (!Resolve(ent, ref ent.Comp))
+ return null;
+ if (!ignoreExposed && !ent.Comp.Anchored)
+ {
+ // Used for things like disposals/cryo to change which air people are exposed to.
+ var ev = new AtmosExposedGetAirEvent((ent, ent.Comp), excite);
+ RaiseLocalEvent(ent, ref ev);
if (ev.Handled)
return ev.Gas;
- }
- // Oops, we did a little bit of code duplication...
- else if(!Resolve(uid, ref transform))
- {
- return GetTileMixture(null, null, Vector2i.Zero, excite);
- }
+ // TODO ATMOS: recursively iterate up through parents
+ // This really needs recursive InContainer metadata flag for performance
+ // And ideally some fast way to get the innermost airtight container.
+ }
- var gridUid = transform.GridUid;
- var mapUid = transform.MapUid;
- var position = _transformSystem.GetGridOrMapTilePosition(uid, transform);
-
- return GetTileMixture(gridUid, mapUid, position, excite);
+ var position = _transformSystem.GetGridTilePositionOrDefault((ent, ent.Comp));
+ return GetTileMixture(grid, map, position, excite);
}
public bool HasAtmosphere(EntityUid gridUid) => _atmosQuery.HasComponent(gridUid);
entity.Comp.InvalidatedCoords.Add(tile);
}
- public GasMixture?[]? GetTileMixtures(Entity<GridAtmosphereComponent?>? grid, Entity<MapAtmosphereComponent?>? map, List<Vector2i> tiles, bool excite = false)
+ public GasMixture?[]? GetTileMixtures(
+ Entity<GridAtmosphereComponent?, GasTileOverlayComponent?>? grid,
+ Entity<MapAtmosphereComponent?>? map,
+ List<Vector2i> tiles,
+ bool excite = false)
{
GasMixture?[]? mixtures = null;
var handled = false;
// If we've been passed a grid, try to let it handle it.
- if (grid is {} gridEnt && Resolve(gridEnt, ref gridEnt.Comp))
+ if (grid is {} gridEnt && Resolve(gridEnt, ref gridEnt.Comp1))
{
+ if (excite)
+ Resolve(gridEnt, ref gridEnt.Comp2);
+
handled = true;
mixtures = new GasMixture?[tiles.Count];
for (var i = 0; i < tiles.Count; i++)
{
var tile = tiles[i];
- if (!gridEnt.Comp.Tiles.TryGetValue(tile, out var atmosTile))
+ if (!gridEnt.Comp1.Tiles.TryGetValue(tile, out var atmosTile))
{
// need to get map atmosphere
handled = false;
mixtures[i] = atmosTile.Air;
if (excite)
- gridEnt.Comp.InvalidatedCoords.Add(tile);
+ {
+ AddActiveTile(gridEnt.Comp1, atmosTile);
+ InvalidateVisuals((gridEnt.Owner, gridEnt.Comp2), tile);
+ }
}
}
return GetTileMixture(entity.Comp.GridUid, entity.Comp.MapUid, indices, excite);
}
- public GasMixture? GetTileMixture(Entity<GridAtmosphereComponent?>? grid, Entity<MapAtmosphereComponent?>? map, Vector2i gridTile, bool excite = false)
+ public GasMixture? GetTileMixture(
+ Entity<GridAtmosphereComponent?, GasTileOverlayComponent?>? grid,
+ Entity<MapAtmosphereComponent?>? map,
+ Vector2i gridTile,
+ bool excite = false)
{
// If we've been passed a grid, try to let it handle it.
if (grid is {} gridEnt
- && Resolve(gridEnt, ref gridEnt.Comp, false)
- && gridEnt.Comp.Tiles.TryGetValue(gridTile, out var tile))
+ && Resolve(gridEnt, ref gridEnt.Comp1, false)
+ && gridEnt.Comp1.Tiles.TryGetValue(gridTile, out var tile))
{
if (excite)
- gridEnt.Comp.InvalidatedCoords.Add(gridTile);
+ {
+ AddActiveTile(gridEnt.Comp1, tile);
+ InvalidateVisuals((grid.Value.Owner, grid.Value.Comp2), gridTile);
+ }
return tile.Air;
}
using Content.Server.Atmos.Components;
using Content.Shared.Atmos;
+using Content.Shared.Atmos.Components;
+using Robust.Shared.Map.Components;
using Robust.Shared.Utility;
namespace Content.Server.Atmos.EntitySystems
excitedGroup.DismantleCooldown = 0;
}
- private void ExcitedGroupSelfBreakdown(GridAtmosphereComponent gridAtmosphere, ExcitedGroup excitedGroup)
+ private void ExcitedGroupSelfBreakdown(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
+ ExcitedGroup excitedGroup)
{
DebugTools.Assert(!excitedGroup.Disposed, "Excited group is disposed!");
- DebugTools.Assert(gridAtmosphere.ExcitedGroups.Contains(excitedGroup), "Grid Atmosphere does not contain Excited Group!");
+ DebugTools.Assert(ent.Comp1.ExcitedGroups.Contains(excitedGroup), "Grid Atmosphere does not contain Excited Group!");
var combined = new GasMixture(Atmospherics.CellVolume);
var tileSize = excitedGroup.Tiles.Count;
if (tileSize == 0)
{
- ExcitedGroupDispose(gridAtmosphere, excitedGroup);
+ ExcitedGroupDispose(ent.Comp1, excitedGroup);
return;
}
continue;
tile.Air.CopyFromMutable(combined);
- InvalidateVisuals(tile.GridIndex, tile.GridIndices);
+ InvalidateVisuals(ent, tile);
}
excitedGroup.BreakdownCooldown = 0;
-using System.Linq;
using Content.Server.Atmos.Components;
using Content.Server.Atmos.Reactions;
using Content.Shared.Atmos;
}
/// <summary>
- /// Update array of adjacent tiles and the adjacency flags. Optionally activates all tiles with modified adjacencies.
+ /// Update array of adjacent tiles and the adjacency flags.
/// </summary>
private void UpdateAdjacentTiles(
Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
if (activate)
AddActiveTile(atmos, adjacent);
- var oppositeDirection = direction.GetOpposite();
+ var oppositeIndex = i.ToOppositeIndex();
+ var oppositeDirection = (AtmosDirection) (1 << oppositeIndex);
+
if (adjBlockDirs.IsFlagSet(oppositeDirection) || blockedDirs.IsFlagSet(direction))
{
// Adjacency is blocked by some airtight entity.
tile.AdjacentBits &= ~direction;
adjacent.AdjacentBits &= ~oppositeDirection;
tile.AdjacentTiles[i] = null;
- adjacent.AdjacentTiles[oppositeDirection.ToIndex()] = null;
+ adjacent.AdjacentTiles[oppositeIndex] = null;
}
else
{
tile.AdjacentBits |= direction;
adjacent.AdjacentBits |= oppositeDirection;
tile.AdjacentTiles[i] = adjacent;
- adjacent.AdjacentTiles[oppositeDirection.ToIndex()] = tile;
+ adjacent.AdjacentTiles[oppositeIndex] = tile;
}
DebugTools.Assert(!(tile.AdjacentBits.IsFlagSet(direction) ^
using Content.Server.Atmos.Components;
using Content.Server.Atmos.Reactions;
using Content.Shared.Atmos;
+using Content.Shared.Atmos.Components;
using Content.Shared.Audio;
using Content.Shared.Database;
using Robust.Shared.Audio;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Player;
namespace Content.Server.Atmos.EntitySystems
[ViewVariables(VVAccess.ReadWrite)]
public string? HotspotSound { get; private set; } = "/Audio/Effects/fire.ogg";
- private void ProcessHotspot(GridAtmosphereComponent gridAtmosphere, TileAtmosphere tile)
+ private void ProcessHotspot(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
+ TileAtmosphere tile)
{
+ var gridAtmosphere = ent.Comp1;
if (!tile.Hotspot.Valid)
{
gridAtmosphere.HotspotTiles.Remove(tile);
return;
}
- if (!tile.Excited)
- {
- AddActiveTile(gridAtmosphere, tile);
- }
+ AddActiveTile(gridAtmosphere, tile);
if (!tile.Hotspot.SkippedFirstProcess)
{
|| tile.Air == null || tile.Air.GetMoles(Gas.Oxygen) < 0.5f || (tile.Air.GetMoles(Gas.Plasma) < 0.5f && tile.Air.GetMoles(Gas.Tritium) < 0.5f))
{
tile.Hotspot = new Hotspot();
- InvalidateVisuals(tile.GridIndex, tile.GridIndices);
+ InvalidateVisuals(ent, tile);
return;
}
using Content.Server.Atmos.Components;
using Content.Shared.Atmos;
using Content.Shared.Atmos.Components;
+using Robust.Shared.Map.Components;
using Robust.Shared.Utility;
namespace Content.Server.Atmos.EntitySystems
{
public sealed partial class AtmosphereSystem
{
- private void ProcessCell(GridAtmosphereComponent gridAtmosphere, TileAtmosphere tile, int fireCount, GasTileOverlayComponent visuals)
+ private void ProcessCell(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
+ TileAtmosphere tile, int fireCount)
{
+ var gridAtmosphere = ent.Comp1;
// Can't process a tile without air
if (tile.Air == null)
{
shouldShareAir = true;
} else if (CompareExchange(tile.Air, enemyTile.Air) != GasCompareResult.NoExchange)
{
- if (!enemyTile.Excited)
- {
- AddActiveTile(gridAtmosphere, enemyTile);
- }
-
+ AddActiveTile(gridAtmosphere, enemyTile);
if (ExcitedGroups)
{
var excitedGroup = tile.ExcitedGroup;
}
else
{
- ConsiderPressureDifference(gridAtmosphere, enemyTile, direction.GetOpposite(), -difference);
+ ConsiderPressureDifference(gridAtmosphere, enemyTile, i.ToOppositeDir(), -difference);
}
}
if(tile.Air != null)
React(tile.Air, tile);
- InvalidateVisuals(tile.GridIndex, tile.GridIndices, visuals);
+ InvalidateVisuals(ent, tile);
var remove = true;
/// <param name="tile">Tile Atmosphere to be activated.</param>
private void AddActiveTile(GridAtmosphereComponent gridAtmosphere, TileAtmosphere tile)
{
- if (tile.Air == null)
+ if (tile.Air == null || tile.Excited)
return;
tile.Excited = true;
if (otherTile2.MonstermosInfo.LastSlowQueueCycle == queueCycleSlow) continue;
_equalizeQueue[queueLength++] = otherTile2;
otherTile2.MonstermosInfo.LastSlowQueueCycle = queueCycleSlow;
- otherTile2.MonstermosInfo.CurrentTransferDirection = direction.GetOpposite();
+ otherTile2.MonstermosInfo.CurrentTransferDirection = k.ToOppositeDir();
otherTile2.MonstermosInfo.CurrentTransferAmount = 0;
if (otherTile2.MonstermosInfo.MoleDelta < 0)
{
if (otherTile2.MonstermosInfo.LastSlowQueueCycle == queueCycleSlow) continue;
_equalizeQueue[queueLength++] = otherTile2;
otherTile2.MonstermosInfo.LastSlowQueueCycle = queueCycleSlow;
- otherTile2.MonstermosInfo.CurrentTransferDirection = direction.GetOpposite();
+ otherTile2.MonstermosInfo.CurrentTransferDirection = k.ToOppositeDir();
otherTile2.MonstermosInfo.CurrentTransferAmount = 0;
if (otherTile2.MonstermosInfo.MoleDelta > 0)
for (var i = 0; i < tileCount; i++)
{
var otherTile = _equalizeTiles[i]!;
- FinalizeEq(gridAtmosphere, otherTile, ent);
+ FinalizeEq(ent, otherTile);
}
for (var i = 0; i < tileCount; i++)
if(tile2.Space)
continue;
- tile2.MonstermosInfo.CurrentTransferDirection = direction.GetOpposite();
+ tile2.MonstermosInfo.CurrentTransferDirection = j.ToOppositeDir();
tile2.MonstermosInfo.CurrentTransferAmount = 0.0f;
tile2.PressureSpecificTarget = otherTile.PressureSpecificTarget;
tile2.MonstermosInfo.LastSlowQueueCycle = queueCycleSlow;
otherTile.Air.Temperature = Atmospherics.TCMB;
}
- InvalidateVisuals(otherTile.GridIndex, otherTile.GridIndices, visuals);
+ InvalidateVisuals(ent, otherTile);
HandleDecompressionFloorRip(mapGrid, otherTile, otherTile.MonstermosInfo.CurrentTransferAmount);
}
UpdateAdjacentTiles(ent, tile);
UpdateAdjacentTiles(ent, other);
- InvalidateVisuals(tile.GridIndex, tile.GridIndices, ent);
- InvalidateVisuals(other.GridIndex, other.GridIndices, ent);
+ InvalidateVisuals(ent, tile);
+ InvalidateVisuals(ent, other);
}
- private void FinalizeEq(GridAtmosphereComponent gridAtmosphere, TileAtmosphere tile, GasTileOverlayComponent? visuals)
+ private void FinalizeEq(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
+ TileAtmosphere tile)
{
Span<float> transferDirections = stackalloc float[Atmospherics.Directions];
var hasTransferDirs = false;
// Everything that calls this method already ensures that Air will not be null.
if (tile.Air!.TotalMoles < amount)
- FinalizeEqNeighbors(gridAtmosphere, tile, transferDirections, visuals);
+ FinalizeEqNeighbors(ent, tile, transferDirections);
- otherTile.MonstermosInfo[direction.GetOpposite()] = 0;
+ otherTile.MonstermosInfo[i.ToOppositeDir()] = 0;
Merge(otherTile.Air, tile.Air.Remove(amount));
- InvalidateVisuals(tile.GridIndex, tile.GridIndices, visuals);
- InvalidateVisuals(otherTile.GridIndex, otherTile.GridIndices, visuals);
- ConsiderPressureDifference(gridAtmosphere, tile, direction, amount);
+ InvalidateVisuals(ent, tile);
+ InvalidateVisuals(ent, otherTile);
+ ConsiderPressureDifference(ent, tile, direction, amount);
}
}
- private void FinalizeEqNeighbors(GridAtmosphereComponent gridAtmosphere, TileAtmosphere tile, ReadOnlySpan<float> transferDirs, GasTileOverlayComponent? visuals)
+ private void FinalizeEqNeighbors(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
+ TileAtmosphere tile, ReadOnlySpan<float> transferDirs)
{
for (var i = 0; i < Atmospherics.Directions; i++)
{
var amount = transferDirs[i];
// Since AdjacentBits is set, AdjacentTiles[i] wouldn't be null, and neither would its air.
if(amount < 0 && tile.AdjacentBits.IsFlagSet(direction))
- FinalizeEq(gridAtmosphere, tile.AdjacentTiles[i]!, visuals); // A bit of recursion if needed.
+ FinalizeEq(ent, tile.AdjacentTiles[i]!); // A bit of recursion if needed.
}
}
Log.Error($"Encountered null-tile in {nameof(AdjustEqMovement)}. Trace: {Environment.StackTrace}");
return;
}
- var adj = tile.AdjacentTiles[direction.ToIndex()];
+
+ var idx = direction.ToIndex();
+ var adj = tile.AdjacentTiles[idx];
if (adj == null)
{
var nonNull = tile.AdjacentTiles.Where(x => x != null).Count();
}
tile.MonstermosInfo[direction] += amount;
- adj.MonstermosInfo[direction.GetOpposite()] -= amount;
+ adj.MonstermosInfo[idx.ToOppositeDir()] -= amount;
}
private void HandleDecompressionFloorRip(MapGridComponent mapGrid, TileAtmosphere tile, float sum)
DebugTools.Assert(atmosphere.Tiles.GetValueOrDefault(tile.GridIndices) == tile);
UpdateAdjacentTiles(ent, tile, activate: true);
UpdateTileAir(ent, tile, volume);
- InvalidateVisuals(uid, tile.GridIndices, visuals);
+ InvalidateVisuals(ent, tile);
if (number++ < InvalidCoordinatesLagCheckIterations)
continue;
return true;
}
- private bool ProcessActiveTiles(GridAtmosphereComponent atmosphere, GasTileOverlayComponent visuals)
+ private bool ProcessActiveTiles(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent)
{
+ var atmosphere = ent.Comp1;
if(!atmosphere.ProcessingPaused)
QueueRunTiles(atmosphere.CurrentRunTiles, atmosphere.ActiveTiles);
var number = 0;
while (atmosphere.CurrentRunTiles.TryDequeue(out var tile))
{
- ProcessCell(atmosphere, tile, atmosphere.UpdateCounter, visuals);
+ ProcessCell(ent, tile, atmosphere.UpdateCounter);
if (number++ < LagCheckIterations)
continue;
return true;
}
- private bool ProcessExcitedGroups(GridAtmosphereComponent gridAtmosphere)
+ private bool ProcessExcitedGroups(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent)
{
+ var gridAtmosphere = ent.Comp1;
if (!gridAtmosphere.ProcessingPaused)
{
gridAtmosphere.CurrentRunExcitedGroups.Clear();
excitedGroup.DismantleCooldown++;
if (excitedGroup.BreakdownCooldown > Atmospherics.ExcitedGroupBreakdownCycles)
- ExcitedGroupSelfBreakdown(gridAtmosphere, excitedGroup);
+ ExcitedGroupSelfBreakdown(ent, excitedGroup);
else if (excitedGroup.DismantleCooldown > Atmospherics.ExcitedGroupsDismantleCycles)
DeactivateGroupTiles(gridAtmosphere, excitedGroup);
// TODO ATMOS. What is the point of this? why is this only de-exciting the group? Shouldn't it also dismantle it?
return true;
}
- private bool ProcessHotspots(GridAtmosphereComponent atmosphere)
+ private bool ProcessHotspots(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent)
{
+ var atmosphere = ent.Comp1;
if(!atmosphere.ProcessingPaused)
QueueRunTiles(atmosphere.CurrentRunTiles, atmosphere.HotspotTiles);
var number = 0;
while (atmosphere.CurrentRunTiles.TryDequeue(out var hotspot))
{
- ProcessHotspot(atmosphere, hotspot);
+ ProcessHotspot(ent, hotspot);
if (number++ < LagCheckIterations)
continue;
return num * AtmosTime;
}
- private bool ProcessAtmosDevices(GridAtmosphereComponent atmosphere)
+ private bool ProcessAtmosDevices(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
+ Entity<MapAtmosphereComponent?> map)
{
+ var atmosphere = ent.Comp1;
if (!atmosphere.ProcessingPaused)
{
atmosphere.CurrentRunAtmosDevices.Clear();
var time = _gameTiming.CurTime;
var number = 0;
- var ev = new AtmosDeviceUpdateEvent(RealAtmosTime());
+ var ev = new AtmosDeviceUpdateEvent(RealAtmosTime(), (ent, ent.Comp1, ent.Comp2), map);
while (atmosphere.CurrentRunAtmosDevices.TryDequeue(out var device))
{
RaiseLocalEvent(device, ref ev);
var ent = _currentRunAtmosphere[_currentRunAtmosphereIndex];
var (owner, atmosphere, visuals, grid, xform) = ent;
- if (!TryComp(owner, out TransformComponent? x)
- || x.MapUid == null
- || TerminatingOrDeleted(x.MapUid.Value)
- || x.MapID == MapId.Nullspace)
+ if (xform.MapUid == null
+ || TerminatingOrDeleted(xform.MapUid.Value)
+ || xform.MapID == MapId.Nullspace)
{
- Log.Error($"Attempted to process atmos without a map? Entity: {ToPrettyString(owner)}. Map: {ToPrettyString(x?.MapUid)}. MapId: {x?.MapID}");
+ Log.Error($"Attempted to process atmos without a map? Entity: {ToPrettyString(owner)}. Map: {ToPrettyString(xform?.MapUid)}. MapId: {xform?.MapID}");
continue;
}
// We subtract it so it takes lost time into account.
atmosphere.Timer -= AtmosTime;
+ var map = new Entity<MapAtmosphereComponent?>(xform.MapUid.Value, _mapAtmosQuery.CompOrNull(xform.MapUid.Value));
+
switch (atmosphere.State)
{
case AtmosphereProcessingState.Revalidate:
atmosphere.State = AtmosphereProcessingState.ActiveTiles;
continue;
case AtmosphereProcessingState.ActiveTiles:
- if (!ProcessActiveTiles(ent, ent))
+ if (!ProcessActiveTiles(ent))
{
atmosphere.ProcessingPaused = true;
return;
atmosphere.State = ExcitedGroups ? AtmosphereProcessingState.ExcitedGroups : AtmosphereProcessingState.HighPressureDelta;
continue;
case AtmosphereProcessingState.ExcitedGroups:
- if (!ProcessExcitedGroups(atmosphere))
+ if (!ProcessExcitedGroups(ent))
{
atmosphere.ProcessingPaused = true;
return;
atmosphere.State = AtmosphereProcessingState.Hotspots;
continue;
case AtmosphereProcessingState.Hotspots:
- if (!ProcessHotspots(atmosphere))
+ if (!ProcessHotspots(ent))
{
atmosphere.ProcessingPaused = true;
return;
atmosphere.State = AtmosphereProcessingState.AtmosDevices;
continue;
case AtmosphereProcessingState.AtmosDevices:
- if (!ProcessAtmosDevices(atmosphere))
+ if (!ProcessAtmosDevices(ent, map))
{
atmosphere.ProcessingPaused = true;
return;
if (!directions.IsFlagSet(direction))
continue;
- var adjacent = tile.AdjacentTiles[direction.ToIndex()];
+ var adjacent = tile.AdjacentTiles[i];
// TODO ATMOS handle adjacent being null.
if (adjacent == null || adjacent.ThermalConductivity == 0f)
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
- public void InvalidateVisuals(EntityUid gridUid, Vector2i tile, GasTileOverlayComponent? comp = null)
+ public void InvalidateVisuals(Entity<GasTileOverlayComponent?> grid, Vector2i tile)
{
- _gasTileOverlaySystem.Invalidate(gridUid, tile, comp);
+ _gasTileOverlaySystem.Invalidate(grid, tile);
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private void InvalidateVisuals(
+ Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
+ TileAtmosphere tile)
+ {
+ _gasTileOverlaySystem.Invalidate((ent.Owner, ent.Comp2), tile.GridIndices);
}
/// <summary>
var query = EntityQueryEnumerator<AtmosExposedComponent, TransformComponent>();
while (query.MoveNext(out var uid, out _, out var transform))
{
- var air = GetContainingMixture(uid, transform:transform);
+ var air = GetContainingMixture((uid, transform));
if (air == null)
continue;
private void ReleaseGas(Entity<GasTankComponent> gasTank)
{
var removed = RemoveAirVolume(gasTank, gasTank.Comp.ValveOutputRate * TimerDelay);
- var environment = _atmosphereSystem.GetContainingMixture(gasTank, false, true);
+ var environment = _atmosphereSystem.GetContainingMixture(gasTank.Owner, false, true);
if (environment != null)
{
_atmosphereSystem.Merge(environment, removed);
private float _updateInterval;
private int _thresholds;
+ private EntityQuery<GasTileOverlayComponent> _query;
public override void Initialize()
{
SubscribeLocalEvent<RoundRestartCleanupEvent>(Reset);
SubscribeLocalEvent<GasTileOverlayComponent, ComponentStartup>(OnStartup);
+ _query = GetEntityQuery<GasTileOverlayComponent>();
}
private void OnStartup(EntityUid uid, GasTileOverlayComponent component, ComponentStartup args)
private void UpdateThresholds(int value) => _thresholds = value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
- public void Invalidate(EntityUid grid, Vector2i index, GasTileOverlayComponent? comp = null)
+ public void Invalidate(Entity<GasTileOverlayComponent?> grid, Vector2i index)
{
- if (Resolve(grid, ref comp))
- comp.InvalidTiles.Add(index);
+ if (_query.Resolve(grid.Owner, ref grid.Comp))
+ grid.Comp.InvalidTiles.Add(index);
}
private void OnPlayerStatusChanged(object? sender, SessionStatusEventArgs e)
private void OnAtmosUpdate(EntityUid uid, HeatExchangerComponent comp, ref AtmosDeviceUpdateEvent args)
{
- if (!TryComp(uid, out NodeContainerComponent? nodeContainer)
- || !TryComp(uid, out AtmosDeviceComponent? device)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.InletName, out PipeNode? inlet)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.OutletName, out PipeNode? outlet))
+ // make sure that the tile the device is on isn't blocked by a wall or something similar.
+ if (args.Grid is {} grid
+ && _transform.TryGetGridTilePosition(uid, out var tile)
+ && _atmosphereSystem.IsTileAirBlocked(grid, tile))
{
return;
}
- // make sure that the tile the device is on isn't blocked by a wall or something similar.
- var xform = Transform(uid);
- if (_transform.TryGetGridTilePosition(uid, out var tile))
- {
- // TryGetGridTilePosition() already returns false if GridUid is null, but the null checker isn't smart enough yet
- if (xform.GridUid != null && _atmosphereSystem.IsTileAirBlocked(xform.GridUid.Value, tile))
- {
- return;
- }
- }
+ if (!_nodeContainer.TryGetNodes(uid, comp.InletName, comp.OutletName, out PipeNode? inlet, out PipeNode? outlet))
+ return;
var dt = args.dt;
if (!this.IsPowered(uid, EntityManager))
return;
- // can't hurt
- // (in case something is making AtmosDeviceUpdateEvents
- // outside the typical device loop)
- if (!TryComp<AtmosDeviceComponent>(uid, out var atmosDeviceComponent)
- || atmosDeviceComponent.JoinedGrid == null)
+ if (args.Grid == null)
return;
// if we're not monitoring atmos, don't bother
private void OnPassiveGateUpdated(EntityUid uid, GasPassiveGateComponent gate, ref AtmosDeviceUpdateEvent args)
{
- if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
- return;
-
- if (!_nodeContainer.TryGetNode(nodeContainer, gate.InletName, out PipeNode? inlet)
- || !_nodeContainer.TryGetNode(nodeContainer, gate.OutletName, out PipeNode? outlet))
+ if (!_nodeContainer.TryGetNodes(uid, gate.InletName, gate.OutletName, out PipeNode? inlet, out PipeNode? outlet))
return;
var n1 = inlet.Air.TotalMoles;
private void OnPumpUpdated(EntityUid uid, GasPressurePumpComponent pump, ref AtmosDeviceUpdateEvent args)
{
if (!pump.Enabled
- || !EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer)
- || !_nodeContainer.TryGetNode(nodeContainer, pump.InletName, out PipeNode? inlet)
- || !_nodeContainer.TryGetNode(nodeContainer, pump.OutletName, out PipeNode? outlet))
+ || !_nodeContainer.TryGetNodes(uid, pump.InletName, pump.OutletName, out PipeNode? inlet, out PipeNode? outlet))
{
_ambientSoundSystem.SetAmbience(uid, false);
return;
if (!EntityManager.GetComponent<TransformComponent>(ent).Anchored || !args.IsInDetailsRange) // Not anchored? Out of range? No status.
return;
- if (!EntityManager.TryGetComponent(ent, out NodeContainerComponent? nodeContainer)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.InletName, out PipeNode? inlet)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.OutletName, out PipeNode? _))
- {
+ if (!_nodeContainer.TryGetNode(ent.Owner, comp.InletName, out PipeNode? inlet))
return;
- }
using (args.PushGroup(nameof(GasRecyclerComponent)))
{
private void OnUpdate(Entity<GasRecyclerComponent> ent, ref AtmosDeviceUpdateEvent args)
{
var comp = ent.Comp;
- if (!EntityManager.TryGetComponent(ent, out NodeContainerComponent? nodeContainer)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.InletName, out PipeNode? inlet)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.OutletName, out PipeNode? outlet))
+ if (!_nodeContainer.TryGetNodes(ent.Owner, comp.InletName, comp.OutletName, out PipeNode? inlet, out PipeNode? outlet))
{
_ambientSoundSystem.SetAmbience(ent, false);
return;
public void Set(EntityUid uid, GasValveComponent component, bool value)
{
component.Open = value;
- if (TryComp(uid, out NodeContainerComponent? nodeContainer)
- && _nodeContainer.TryGetNode(nodeContainer, component.InletName, out PipeNode? inlet)
- && _nodeContainer.TryGetNode(nodeContainer, component.OutletName, out PipeNode? outlet))
+
+ if (_nodeContainer.TryGetNodes(uid, component.InletName, component.OutletName, out PipeNode? inlet, out PipeNode? outlet))
{
if (TryComp<AppearanceComponent>(uid, out var appearance))
{
private void OnVolumePumpUpdated(EntityUid uid, GasVolumePumpComponent pump, ref AtmosDeviceUpdateEvent args)
{
- if (!pump.Enabled
- || !TryComp(uid, out NodeContainerComponent? nodeContainer)
- || !TryComp(uid, out AtmosDeviceComponent? device)
- || !_nodeContainer.TryGetNode(nodeContainer, pump.InletName, out PipeNode? inlet)
- || !_nodeContainer.TryGetNode(nodeContainer, pump.OutletName, out PipeNode? outlet))
+ if (!pump.Enabled ||
+ !_nodeContainer.TryGetNodes(uid, pump.InletName, pump.OutletName, out PipeNode? inlet, out PipeNode? outlet))
{
_ambientSoundSystem.SetAmbience(uid, false);
return;
using Content.Server.Atmos.Components;
+using Content.Shared.Atmos.Components;
namespace Content.Server.Atmos.Piping.Components;
/// Use this for atmos devices instead of <see cref="EntitySystem.Update"/>.
/// </summary>
[ByRefEvent]
-public readonly struct AtmosDeviceUpdateEvent
+public readonly struct AtmosDeviceUpdateEvent(float dt, Entity<GridAtmosphereComponent, GasTileOverlayComponent>? grid, Entity<MapAtmosphereComponent?>? map)
{
/// <summary>
/// Time elapsed since last update, in seconds. Multiply values used in the update handler
/// by this number to make them tickrate-invariant. Use this number instead of AtmosphereSystem.AtmosTime.
/// </summary>
- public readonly float dt;
+ public readonly float dt = dt;
- public AtmosDeviceUpdateEvent(float dt)
- {
- this.dt = dt;
- }
+ /// <summary>
+ /// The grid that this device is currently on.
+ /// </summary>
+ public readonly Entity<GridAtmosphereComponent?, GasTileOverlayComponent?>? Grid = grid == null
+ ? null
+ : (grid.Value, grid.Value, grid.Value);
+
+ /// <summary>
+ /// The map that the device & grid is on.
+ /// </summary>
+ public readonly Entity<MapAtmosphereComponent?>? Map = map;
}
/// <summary>
_timer -= _atmosphereSystem.AtmosTime;
var time = _gameTiming.CurTime;
- var ev = new AtmosDeviceUpdateEvent(_atmosphereSystem.AtmosTime);
+ var ev = new AtmosDeviceUpdateEvent(_atmosphereSystem.AtmosTime, null, null);
foreach (var device in _joinedDevices)
{
+ DebugTools.Assert(!HasComp<GridAtmosphereComponent>(Transform(device).GridUid));
RaiseLocalEvent(device, ref ev);
device.Comp.LastProcess = time;
}
private bool CheckMinerOperation(Entity<GasMinerComponent> ent, [NotNullWhen(true)] out GasMixture? environment)
{
var (uid, miner) = ent;
- environment = _atmosphereSystem.GetContainingMixture(uid, true, true);
-
var transform = Transform(uid);
+ environment = _atmosphereSystem.GetContainingMixture((uid, transform), true, true);
+
var position = _transformSystem.GetGridOrMapTilePosition(uid, transform);
// Space.
private void OnFilterUpdated(EntityUid uid, GasFilterComponent filter, ref AtmosDeviceUpdateEvent args)
{
if (!filter.Enabled
- || !EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer)
- || !EntityManager.TryGetComponent(uid, out AtmosDeviceComponent? device)
- || !_nodeContainer.TryGetNode(nodeContainer, filter.InletName, out PipeNode? inletNode)
- || !_nodeContainer.TryGetNode(nodeContainer, filter.FilterName, out PipeNode? filterNode)
- || !_nodeContainer.TryGetNode(nodeContainer, filter.OutletName, out PipeNode? outletNode)
+ || !_nodeContainer.TryGetNodes(uid, filter.InletName, filter.OutletName, filter.FilterName, out PipeNode? inletNode, out PipeNode? filterNode, out PipeNode? outletNode)
|| outletNode.Air.Pressure >= Atmospherics.MaxOutputPressure) // No need to transfer if target is full.
{
_ambientSoundSystem.SetAmbience(uid, false);
if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
return;
- var gasMixDict = new Dictionary<string, GasMixture?>();
+ args.GasMixtures ??= new Dictionary<string, GasMixture?>();
if(_nodeContainer.TryGetNode(nodeContainer, component.InletName, out PipeNode? inlet))
- gasMixDict.Add(Loc.GetString("gas-analyzer-window-text-inlet"), inlet.Air);
+ args.GasMixtures.Add(Loc.GetString("gas-analyzer-window-text-inlet"), inlet.Air);
if(_nodeContainer.TryGetNode(nodeContainer, component.FilterName, out PipeNode? filterNode))
- gasMixDict.Add(Loc.GetString("gas-analyzer-window-text-filter"), filterNode.Air);
+ args.GasMixtures.Add(Loc.GetString("gas-analyzer-window-text-filter"), filterNode.Air);
if(_nodeContainer.TryGetNode(nodeContainer, component.OutletName, out PipeNode? outlet))
- gasMixDict.Add(Loc.GetString("gas-analyzer-window-text-outlet"), outlet.Air);
+ args.GasMixtures.Add(Loc.GetString("gas-analyzer-window-text-outlet"), outlet.Air);
- args.GasMixtures = gasMixDict;
args.DeviceFlipped = inlet != null && filterNode != null && inlet.CurrentPipeDirection.ToDirection() == filterNode.CurrentPipeDirection.ToDirection().GetClockwise90Degrees();
}
}
{
// TODO ATMOS: Cache total moles since it's expensive.
- if (!mixer.Enabled)
- {
- _ambientSoundSystem.SetAmbience(uid, false);
- return;
- }
-
- if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
- return;
-
- if (!_nodeContainer.TryGetNode(nodeContainer, mixer.InletOneName, out PipeNode? inletOne)
- || !_nodeContainer.TryGetNode(nodeContainer, mixer.InletTwoName, out PipeNode? inletTwo)
- || !_nodeContainer.TryGetNode(nodeContainer, mixer.OutletName, out PipeNode? outlet))
+ if (!mixer.Enabled
+ || !_nodeContainer.TryGetNodes(uid, mixer.InletOneName, mixer.InletTwoName, mixer.OutletName, out PipeNode? inletOne, out PipeNode? inletTwo, out PipeNode? outlet))
{
_ambientSoundSystem.SetAmbience(uid, false);
return;
private void OnUpdate(EntityUid uid, PressureControlledValveComponent comp, ref AtmosDeviceUpdateEvent args)
{
- if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer)
- || !EntityManager.TryGetComponent(uid, out AtmosDeviceComponent? device)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.InletName, out PipeNode? inletNode)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.ControlName, out PipeNode? controlNode)
- || !_nodeContainer.TryGetNode(nodeContainer, comp.OutletName, out PipeNode? outletNode))
+ if (!_nodeContainer.TryGetNodes(uid, comp.InletName, comp.ControlName, comp.OutletName, out PipeNode? inletNode, out PipeNode? controlNode, out PipeNode? outletNode))
{
_ambientSoundSystem.SetAmbience(uid, false);
comp.Enabled = false;
if (!Resolve(uid, ref canister, ref transform))
return;
- var environment = _atmos.GetContainingMixture(uid, false, true);
+ var environment = _atmos.GetContainingMixture((uid, transform), false, true);
if (environment is not null)
_atmos.Merge(environment, canister.Air);
}
else
{
- var environment = _atmos.GetContainingMixture(uid, false, true);
+ var environment = _atmos.GetContainingMixture(uid, args.Grid, args.Map, false, true);
_atmos.ReleaseGasTo(canister.Air, environment, canister.ReleasePressure);
}
}
private void OnCondenserUpdated(Entity<GasCondenserComponent> entity, ref AtmosDeviceUpdateEvent args)
{
- if (!(_power.IsPowered(entity) && TryComp<ApcPowerReceiverComponent>(entity, out var receiver))
- || !TryComp<NodeContainerComponent>(entity, out var nodeContainer)
- || !_nodeContainer.TryGetNode(nodeContainer, entity.Comp.Inlet, out PipeNode? inlet)
+ if (!(TryComp<ApcPowerReceiverComponent>(entity, out var receiver) && _power.IsPowered(entity, receiver))
+ || !_nodeContainer.TryGetNode(entity.Owner, entity.Comp.Inlet, out PipeNode? inlet)
|| !_solution.ResolveSolution(entity.Owner, entity.Comp.SolutionId, ref entity.Comp.Solution, out var solution))
{
return;
if (!injector.Enabled)
return;
- if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
+ if (!_nodeContainer.TryGetNode(uid, injector.InletName, out PipeNode? inlet))
return;
- if (!TryComp(uid, out AtmosDeviceComponent? device))
- return;
-
- if (!_nodeContainer.TryGetNode(nodeContainer, injector.InletName, out PipeNode? inlet))
- return;
-
- var environment = _atmosphereSystem.GetContainingMixture(uid, true, true);
+ var environment = _atmosphereSystem.GetContainingMixture(uid, args.Grid, args.Map, true, true);
if (environment == null)
return;
private void OnPassiveVentUpdated(EntityUid uid, GasPassiveVentComponent vent, ref AtmosDeviceUpdateEvent args)
{
- var environment = _atmosphereSystem.GetContainingMixture(uid, true, true);
+ var environment = _atmosphereSystem.GetContainingMixture(uid, args.Grid, args.Map, true, true);
if (environment == null)
return;
- if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
- return;
-
- if (!_nodeContainer.TryGetNode(nodeContainer, vent.InletName, out PipeNode? inlet))
+ if (!_nodeContainer.TryGetNode(uid, vent.InletName, out PipeNode? inlet))
return;
var inletAir = inlet.Air.RemoveRatio(1f);
private void OnAnchorChanged(EntityUid uid, GasPortableComponent portable, ref AnchorStateChangedEvent args)
{
- if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
- return;
-
- if (!_nodeContainer.TryGetNode(nodeContainer, portable.PortName, out PipeNode? portableNode))
+ if (!_nodeContainer.TryGetNode(uid, portable.PortName, out PipeNode? portableNode))
return;
portableNode.ConnectionsEnabled = args.Anchored;
_atmosphereSystem.AddHeat(heatExchangeGasMixture, dQPipe);
thermoMachine.LastEnergyDelta = dQPipe;
- if (dQLeak != 0f && _atmosphereSystem.GetContainingMixture(uid, excite: true) is { } containingMixture)
+ if (dQLeak != 0f && _atmosphereSystem.GetContainingMixture(uid, args.Grid, args.Map, excite: true) is { } containingMixture)
_atmosphereSystem.AddHeat(containingMixture, dQLeak);
}
}
else
{
- if (!TryComp<NodeContainerComponent>(uid, out var nodeContainer)
- || !_nodeContainer.TryGetNode(nodeContainer, thermoMachine.InletName, out PipeNode? inlet))
+ if (!_nodeContainer.TryGetNode(uid, thermoMachine.InletName, out PipeNode? inlet))
return;
heatExchangeGasMixture = inlet.Air;
}
_ => throw new ArgumentOutOfRangeException()
};
- if (!vent.Enabled
- || !TryComp(uid, out AtmosDeviceComponent? device)
- || !TryComp(uid, out NodeContainerComponent? nodeContainer)
- || !_nodeContainer.TryGetNode(nodeContainer, nodeName, out PipeNode? pipe))
+ if (!vent.Enabled || !_nodeContainer.TryGetNode(uid, nodeName, out PipeNode? pipe))
{
return;
}
- var environment = _atmosphereSystem.GetContainingMixture(uid, true, true);
+ var environment = _atmosphereSystem.GetContainingMixture(uid, args.Grid, args.Map, true, true);
// We're in an air-blocked tile... Do nothing.
if (environment == null)
/// </summary>
private void OnAnalyzed(EntityUid uid, GasVentPumpComponent component, GasAnalyzerScanEvent args)
{
- if (!EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer))
- return;
-
var gasMixDict = new Dictionary<string, GasMixture?>();
// these are both called pipe, above it switches using this so I duplicated that...?
VentPumpDirection.Siphoning => component.Outlet,
_ => throw new ArgumentOutOfRangeException()
};
- if (_nodeContainer.TryGetNode(nodeContainer, nodeName, out PipeNode? pipe))
+ if (_nodeContainer.TryGetNode(uid, nodeName, out PipeNode? pipe))
gasMixDict.Add(nodeName, pipe.Air);
args.GasMixtures = gasMixDict;
private void OnVentScrubberUpdated(EntityUid uid, GasVentScrubberComponent scrubber, ref AtmosDeviceUpdateEvent args)
{
if (_weldable.IsWelded(uid))
- {
- return;
- }
-
- if (!TryComp(uid, out AtmosDeviceComponent? device))
return;
var timeDelta = args.dt;
- if (!scrubber.Enabled
- || !EntityManager.TryGetComponent(uid, out NodeContainerComponent? nodeContainer)
- || !_nodeContainer.TryGetNode(nodeContainer, scrubber.OutletName, out PipeNode? outlet))
+ if (!scrubber.Enabled || !_nodeContainer.TryGetNode(uid, scrubber.OutletName, out PipeNode? outlet))
return;
- var xform = Transform(uid);
-
- if (xform.GridUid == null)
+ if (args.Grid is not {} grid)
return;
- var position = _transformSystem.GetGridTilePositionOrDefault((uid,xform));
- var environment = _atmosphereSystem.GetTileMixture(xform.GridUid, xform.MapUid, position, true);
+ var position = _transformSystem.GetGridTilePositionOrDefault(uid);
+ var environment = _atmosphereSystem.GetTileMixture(grid, args.Map, position, true);
Scrub(timeDelta, scrubber, environment, outlet);
return;
// Scrub adjacent tiles too.
- var enumerator = _atmosphereSystem.GetAdjacentTileMixtures(xform.GridUid.Value, position, false, true);
+ var enumerator = _atmosphereSystem.GetAdjacentTileMixtures(grid, position, false, true);
while (enumerator.MoveNext(out var adjacent))
{
Scrub(timeDelta, scrubber, adjacent, outlet);
private void OnDeviceUpdated(EntityUid uid, PortableScrubberComponent component, ref AtmosDeviceUpdateEvent args)
{
- if (!TryComp(uid, out AtmosDeviceComponent? device))
- return;
-
var timeDelta = args.dt;
if (!component.Enabled)
return;
// If we are on top of a connector port, empty into it.
- if (TryComp<NodeContainerComponent>(uid, out var nodeContainer)
- && _nodeContainer.TryGetNode(nodeContainer, component.PortName, out PortablePipeNode? portableNode)
+ if (_nodeContainer.TryGetNode(uid, component.PortName, out PortablePipeNode? portableNode)
&& portableNode.ConnectionsEnabled)
{
_atmosphereSystem.React(component.Air, portableNode);
return;
}
- var xform = Transform(uid);
-
- if (xform.GridUid == null)
+ if (args.Grid is not {} grid)
return;
- var position = _transformSystem.GetGridTilePositionOrDefault((uid,xform));
- var environment = _atmosphereSystem.GetTileMixture(xform.GridUid, xform.MapUid, position, true);
+ var position = _transformSystem.GetGridTilePositionOrDefault(uid);
+ var environment = _atmosphereSystem.GetTileMixture(grid, args.Map, position, true);
var running = Scrub(timeDelta, component, environment);
// We scrub once to see if we can and set the animation
if (!running)
return;
+
// widenet
- var enumerator = _atmosphereSystem.GetAdjacentTileMixtures(xform.GridUid.Value, position, false, true);
+ var enumerator = _atmosphereSystem.GetAdjacentTileMixtures(grid, position, false, true);
while (enumerator.MoveNext(out var adjacent))
{
Scrub(timeDelta, component, adjacent);
/// </summary>
private void OnAnchorChanged(EntityUid uid, PortableScrubberComponent component, ref AnchorStateChangedEvent args)
{
- if (!TryComp(uid, out NodeContainerComponent? nodeContainer))
- return;
-
- if (!_nodeContainer.TryGetNode(nodeContainer, component.PortName, out PipeNode? portableNode))
+ if (!_nodeContainer.TryGetNode(uid, component.PortName, out PipeNode? portableNode))
return;
portableNode.ConnectionsEnabled = (args.Anchored && _gasPortableSystem.FindGasPortIn(Transform(uid).GridUid, Transform(uid).Coordinates, out _));
/// </summary>
private void OnScrubberAnalyzed(EntityUid uid, PortableScrubberComponent component, GasAnalyzerScanEvent args)
{
- var gasMixDict = new Dictionary<string, GasMixture?> { { Name(uid), component.Air } };
+ args.GasMixtures ??= new Dictionary<string, GasMixture?> { { Name(uid), component.Air } };
// If it's connected to a port, include the port side
- if (TryComp(uid, out NodeContainerComponent? nodeContainer))
- {
- if (_nodeContainer.TryGetNode(nodeContainer, component.PortName, out PipeNode? port))
- gasMixDict.Add(component.PortName, port.Air);
- }
- args.GasMixtures = gasMixDict;
+ if (_nodeContainer.TryGetNode(uid, component.PortName, out PipeNode? port))
+ args.GasMixtures.Add(component.PortName, port.Air);
}
}
}
// If in automatic temperature mode, check if we need to adjust the heat exchange direction
if (spaceHeater.Mode == SpaceHeaterMode.Auto)
{
- var environment = _atmosphereSystem.GetContainingMixture(uid);
+ var environment = _atmosphereSystem.GetContainingMixture(uid, args.Grid, args.Map);
if (environment == null)
return;
public sealed partial class ElectrocutionNode : Node
{
[DataField("cable")]
- public EntityUid CableEntity;
+ public EntityUid? CableEntity;
[DataField("node")]
public string? NodeName;
MapGridComponent? grid,
IEntityManager entMan)
{
- var _nodeContainer = entMan.System<NodeContainerSystem>();
-
- if (!nodeQuery.TryGetComponent(CableEntity, out var nodeContainer))
+ if (CableEntity == null || NodeName == null)
yield break;
- if (_nodeContainer.TryGetNode(nodeContainer, NodeName, out Node? node))
+ var _nodeContainer = entMan.System<NodeContainerSystem>();
+ if (_nodeContainer.TryGetNode(CableEntity.Value, NodeName, out Node? node))
yield return node;
}
}
var direction = (AtmosDirection) (1 << i);
if (ignoreTileBlockers || !blockedDirections.IsFlagSet(direction))
{
- ProcessNewTile(iteration, tile.Offset(direction), direction.GetOpposite());
+ ProcessNewTile(iteration, tile.Offset(direction), i.ToOppositeDir());
}
}
var direction = (AtmosDirection) (1 << i);
if (blockedDirections.IsFlagSet(direction))
{
- list.Add((tile.Offset(direction), direction.GetOpposite()));
+ list.Add((tile.Offset(direction), i.ToOppositeDir()));
}
}
}
if (!unblockedDirections.IsFlagSet(direction))
continue; // explosion cannot propagate in this direction. Ever.
- ProcessNewTile(iteration, tile.Offset(direction), direction.GetOpposite());
+ ProcessNewTile(iteration, tile.Offset(direction), i.ToOppositeDir());
}
}
}
if (args.Handled)
return;
- if (!TryComp<MechComponent>(component.Mech, out var mech) ||
- !TryComp<MechAirComponent>(component.Mech, out var mechAir))
+ if (!TryComp(component.Mech, out MechComponent? mech))
+ return;
+
+ if (mech.Airtight && TryComp(component.Mech, out MechAirComponent? air))
{
+ args.Handled = true;
+ args.Gas = air.Air;
return;
}
- args.Gas = mech.Airtight ? mechAir.Air : _atmosphere.GetContainingMixture(component.Mech);
-
+ args.Gas = _atmosphere.GetContainingMixture(component.Mech, excite: args.Excite);
args.Handled = true;
}
private void OnCryoPodUpdateAtmosphere(Entity<CryoPodComponent> entity, ref AtmosDeviceUpdateEvent args)
{
- if (!TryComp(entity, out NodeContainerComponent? nodeContainer))
- return;
-
- if (!_nodeContainer.TryGetNode(nodeContainer, entity.Comp.PortName, out PortablePipeNode? portNode))
+ if (!_nodeContainer.TryGetNode(entity.Owner, entity.Comp.PortName, out PortablePipeNode? portNode))
return;
if (!TryComp(entity, out CryoPodAirComponent? cryoPodAir))
if (!TryComp(entity, out CryoPodAirComponent? cryoPodAir))
return;
- var gasMixDict = new Dictionary<string, GasMixture?> { { Name(entity.Owner), cryoPodAir.Air } };
+ args.GasMixtures ??= new Dictionary<string, GasMixture?> { { Name(entity.Owner), cryoPodAir.Air } };
// If it's connected to a port, include the port side
- if (TryComp(entity, out NodeContainerComponent? nodeContainer))
- {
- if (_nodeContainer.TryGetNode(nodeContainer, entity.Comp.PortName, out PipeNode? port))
- gasMixDict.Add(entity.Comp.PortName, port.Air);
- }
- args.GasMixtures = gasMixDict;
+ if (_nodeContainer.TryGetNode(entity.Owner, entity.Comp.PortName, out PipeNode? port))
+ args.GasMixtures.Add(entity.Comp.PortName, port.Air);
}
private void OnEjected(Entity<CryoPodComponent> cryoPod, ref EntRemovedFromContainerMessage args)
public sealed class NodeContainerSystem : EntitySystem
{
[Dependency] private readonly NodeGroupSystem _nodeGroupSystem = default!;
+ private EntityQuery<NodeContainerComponent> _query;
public override void Initialize()
{
SubscribeLocalEvent<NodeContainerComponent, ReAnchorEvent>(OnReAnchor);
SubscribeLocalEvent<NodeContainerComponent, MoveEvent>(OnMoveEvent);
SubscribeLocalEvent<NodeContainerComponent, ExaminedEvent>(OnExamine);
+
+ _query = GetEntityQuery<NodeContainerComponent>();
}
public bool TryGetNode<T>(NodeContainerComponent component, string? identifier, [NotNullWhen(true)] out T? node) where T : Node
return false;
}
+ public bool TryGetNode<T>(Entity<NodeContainerComponent?> ent, string identifier, [NotNullWhen(true)] out T? node) where T : Node
+ {
+ if (_query.Resolve(ent, ref ent.Comp, false)
+ && ent.Comp.Nodes.TryGetValue(identifier, out var n)
+ && n is T t)
+ {
+ node = t;
+ return true;
+ }
+
+ node = null;
+ return false;
+ }
+
+ public bool TryGetNodes<T1, T2>(
+ Entity<NodeContainerComponent?> ent,
+ string id1,
+ string id2,
+ [NotNullWhen(true)] out T1? node1,
+ [NotNullWhen(true)] out T2? node2)
+ where T1 : Node
+ where T2 : Node
+ {
+ if (_query.Resolve(ent, ref ent.Comp, false)
+ && ent.Comp.Nodes.TryGetValue(id1, out var n1)
+ && n1 is T1 t1
+ && ent.Comp.Nodes.TryGetValue(id2, out var n2)
+ && n2 is T2 t2)
+ {
+ node1 = t1;
+ node2 = t2;
+ return true;
+ }
+
+ node1 = null;
+ node2 = null;
+ return false;
+ }
+
+ public bool TryGetNodes<T1, T2, T3>(
+ Entity<NodeContainerComponent?> ent,
+ string id1,
+ string id2,
+ string id3,
+ [NotNullWhen(true)] out T1? node1,
+ [NotNullWhen(true)] out T2? node2,
+ [NotNullWhen(true)] out T3? node3)
+ where T1 : Node
+ where T2 : Node
+ where T3 : Node
+ {
+ if (_query.Resolve(ent, ref ent.Comp, false)
+ && ent.Comp.Nodes.TryGetValue(id1, out var n1)
+ && n1 is T1 t1
+ && ent.Comp.Nodes.TryGetValue(id2, out var n2)
+ && n2 is T2 t2
+ && ent.Comp.Nodes.TryGetValue(id3, out var n3)
+ && n2 is T3 t3)
+ {
+ node1 = t1;
+ node2 = t2;
+ node3 = t3;
+ return true;
+ }
+
+ node1 = null;
+ node2 = null;
+ node3 = null;
+ return false;
+ }
+
private void OnInitEvent(EntityUid uid, NodeContainerComponent component, ComponentInit args)
{
foreach (var (key, node) in component.Nodes)
return;
// this should always be possible, as we'll eject the gas tank when it no longer is
- var environment = _atmos.GetContainingMixture(cannon, false, true);
+ var environment = _atmos.GetContainingMixture(cannon.Owner, false, true);
var removed = _gasTank.RemoveAir(gas.Value, component.GasUsage);
if (environment != null && removed != null)
{
public sealed partial class CableVisComponent : Component
{
[ViewVariables(VVAccess.ReadWrite)]
- [DataField("node")]
- public string? Node;
+ [DataField("node", required:true)]
+ public string Node;
}
}
private void UpdateAppearance(EntityUid uid, CableVisComponent cableVis, ref NodeGroupsRebuilt args)
{
- if (!TryComp(uid, out NodeContainerComponent? nodeContainer) || !TryComp(uid, out AppearanceComponent? appearance))
- return;
-
- if (!_nodeContainer.TryGetNode<CableNode>(nodeContainer, cableVis.Node, out var node))
+ if (!_nodeContainer.TryGetNode(uid, cableVis.Node, out CableNode? node))
return;
var transform = Transform(uid);
};
}
- _appearance.SetData(uid, WireVisVisuals.ConnectedMask, mask, appearance);
+ _appearance.SetData(uid, WireVisVisuals.ConnectedMask, mask);
}
}
}
{
var timeDelta = args.dt;
- if (!HasComp<AtmosDeviceComponent>(uid)
- || !TryComp<NodeContainerComponent>(uid, out var nodeContainer)
- || !_nodeContainer.TryGetNode<PipeNode>(nodeContainer, "pipe", out var pipe))
- {
+ if (!_nodeContainer.TryGetNode(uid, "pipe", out PipeNode? pipe))
return;
- }
// if we're below the max temperature, then we are simply consuming our target gas
if (pipe.Air.Temperature <= component.MaxTemperature)
if (component.OffVentGas)
{
// eject the gas into the atmosphere
- var mix = _atmosphereSystem.GetContainingMixture(uid, false, true);
+ var mix = _atmosphereSystem.GetContainingMixture(uid, args.Grid, args.Map, false, true);
if (mix is not null)
_atmosphereSystem.Merge(res, mix);
}
// Add the normal neighbors.
for (var i = 0; i < 4; i++)
{
- var direction = (Direction) (i * 2);
- var atmosDir = direction.ToAtmosDirection();
- var neighborPos = SharedMapSystem.GetDirection(tile, direction);
- neighborTiles.Add((comp.GridUid.Value, grid, neighborPos, atmosDir, atmosDir.GetOpposite()));
+ var atmosDir = (AtmosDirection) (1 << i);
+ var neighborPos = tile.Offset(atmosDir);
+ neighborTiles.Add((comp.GridUid.Value, grid, neighborPos, atmosDir, i.ToOppositeDir()));
}
foreach (var (neighborEnt, neighborGrid, neighborPos, ourAtmosDir, otherAtmosDir) in neighborTiles)
-using System.Runtime.CompilerServices;
+using System.Numerics;
+using System.Runtime.CompilerServices;
using Robust.Shared.Serialization;
namespace Content.Shared.Atmos
South = 1 << 1, // 2
East = 1 << 2, // 4
West = 1 << 3, // 8
+ // If more directions are added, note that AtmosDirectionHelpers.ToOppositeIndex() expects opposite directions
+ // to come in pairs
NorthEast = North | East, // 5
SouthEast = South | East, // 6
};
}
+ /// <summary>
+ /// This returns the index that corresponds to the opposite direction of some other direction index.
+ /// I.e., <c>1<<OppositeIndex(i) == (1<<i).GetOpposite()</c>
+ /// </summary>
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static int ToOppositeIndex(this int index)
+ {
+ return index ^ 1;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static AtmosDirection ToOppositeDir(this int index)
+ {
+ return (AtmosDirection) (1 << (index ^ 1));
+ }
+
public static Direction ToDirection(this AtmosDirection direction)
{
return direction switch
return angle.GetDir().ToAtmosDirection();
}
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int ToIndex(this AtmosDirection direction)
{
// This will throw if you pass an invalid direction. Not this method's fault, but yours!
- return (int) Math.Log2((int) direction);
+ return BitOperations.Log2((uint)direction);
}
public static AtmosDirection WithFlag(this AtmosDirection direction, AtmosDirection other)
[Dependency] private readonly SharedToolSystem _toolSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
-
- public bool IsWelded(EntityUid uid, WeldableComponent? component = null)
- {
- if (!Resolve(uid, ref component, false))
- return false;
-
- return component.IsWelded;
- }
+ private EntityQuery<WeldableComponent> _query;
public override void Initialize()
{
SubscribeLocalEvent<WeldableComponent, WeldFinishedEvent>(OnWeldFinished);
SubscribeLocalEvent<LayerChangeOnWeldComponent, WeldableChangedEvent>(OnWeldChanged);
SubscribeLocalEvent<WeldableComponent, ExaminedEvent>(OnExamine);
+
+ _query = GetEntityQuery<WeldableComponent>();
+ }
+
+ public bool IsWelded(EntityUid uid, WeldableComponent? component = null)
+ {
+ return _query.Resolve(uid, ref component, false) && component.IsWelded;
}
private void OnExamine(EntityUid uid, WeldableComponent component, ExaminedEvent args)
private bool CanWeld(EntityUid uid, EntityUid tool, EntityUid user, WeldableComponent? component = null)
{
- if (!Resolve(uid, ref component))
+ if (!_query.Resolve(uid, ref component))
return false;
// Other component systems
private bool TryWeld(EntityUid uid, EntityUid tool, EntityUid user, WeldableComponent? component = null)
{
- if (!Resolve(uid, ref component))
+ if (!_query.Resolve(uid, ref component))
return false;
if (!CanWeld(uid, tool, user, component))
private void UpdateAppearance(EntityUid uid, WeldableComponent? component = null)
{
- if (!Resolve(uid, ref component))
- return;
-
- if (!TryComp(uid, out AppearanceComponent? appearance))
- return;
- _appearance.SetData(uid, WeldableVisuals.IsWelded, component.IsWelded, appearance);
+ if (_query.Resolve(uid, ref component))
+ _appearance.SetData(uid, WeldableVisuals.IsWelded, component.IsWelded);
}
public void SetWeldedState(EntityUid uid, bool state, WeldableComponent? component = null)
{
- if (!Resolve(uid, ref component))
+ if (!_query.Resolve(uid, ref component))
return;
if (component.IsWelded == state)
public void SetWeldingTime(EntityUid uid, TimeSpan time, WeldableComponent? component = null)
{
- if (!Resolve(uid, ref component))
+ if (!_query.Resolve(uid, ref component))
return;
if (component.WeldingTime.Equals(time))
# Special entity used to attach to power networks as load when somebody gets electrocuted.
- type: entity
id: VirtualElectrocutionLoadBase
- noSpawn: true
+ abstract: true
components:
- type: Electrocution
- type: Icon
projects / space-station-14.git / commitdiff