PipeNet (#1626)

* PipeNode

* Pipe prototypes

* Fixes Default NodeGroup not being registered by NodeGroupFactory

* GasNet

* PumpComponent

* IPipeNet

* PipeComponent

* misc naming, yaml

* PipeComponent rework

* PipeNet gas transfer from pipes

* PipeNet correctly combines gas on combining with other group

* Client ignores piping components

* AfterRemake

* PipeNet remake simplification

* IGasMixtureHolder on PipeComponent, IPipeNet

* PipeContainerComponent

* BasePump

* DebugPump

* IgnoredComponent fix

* Pipe LocalAir and Air

* comments

* Pump fix

* PipeNet fix

* name simplification

* PipeDirection name changes

* BaseVentComponent and DebugVentComponent

* Moves Pipe to own file

* DebugVentComponent moved to own file

* BaseScrubberComponent

* DebugScrubberComponent

* IgnoredComponents update

* scrubber prototype

* vent prototype fix

* comments

* Removes vent and scrubber PipeDirection check

* PipeContainer, Pipe, and PipeNode refactor

* Yaml cleanup

* pump prototype fix

* Removes AssumeAir usage from old IGasMixtureHolders

* Simplfies Vent & Scrubber to use AtmosHelper methods

* Vents and scrubbers invalidate the coordinate they changed the gas of

* UpdatedPipingComponent

* ScrubberComponent renamed to SiphonComponent

* Removes PumpSystem

* Removes framTime from UpdatedPiping

* PipeNetDevices

* PipeNetDevice updated by GridAtmosphereComponent

* PipeNets react from update in GridAtmosphereComponent

* GridAtmosphereComponent stores PipeNets/PipeNetDevices to be updated in queue

* diff fix

* Removes debug gas starting in pipes

* type safety in IPipeNet when combining groups

* null checks

* GridAtmos stores PipeNets and PipeNetDevices in List

* comments

* rogue curly bracket

* ProcessPipeNets update fix

* RemovePipeNet fix

* PipeNet update() unique index

* fix diff

* Integration test fixes

* Error Logging

* error fix

Co-authored-by: py01 <pyronetics01@gmail.com>

Content.Client/IgnoredComponents.cs

@@ -160,6 +160,9 @@
             "Metabolism",
             "AiFactionTag",
             "PressureProtection",
+            "DebugPump",
+            "DebugVent",
+            "DebugSiphon",
         };
     }
 }

Content.Server/Atmos/IGridAtmosphereComponent.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using Content.Server.GameObjects.Components.Atmos.Piping;
+using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
 using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.Map;
 
@@ -146,5 +148,13 @@ namespace Content.Server.Atmos
         float GetVolumeForCells(int cellCount);
 
         void Update(float frameTime);
+
+        void AddPipeNet(IPipeNet pipeNet);
+
+        void RemovePipeNet(IPipeNet pipeNet);
+
+        void AddPipeNetDevice(PipeNetDeviceComponent pipeNetDevice);
+
+        void RemovePipeNetDevice(PipeNetDeviceComponent pipeNetDevice);
     }
 }

Content.Server/GameObjects/Components/Atmos/GridAtmosphereComponent.cs

@@ -5,6 +5,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using Content.Server.Atmos;
+using Content.Server.GameObjects.Components.Atmos.Piping;
+using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
 using Content.Shared.Atmos;
 using Content.Shared.Maps;
 using Robust.Server.Interfaces.GameObjects;
@@ -73,6 +75,22 @@ namespace Content.Server.GameObjects.Components.Atmos
         [ViewVariables]
         private HashSet<TileAtmosphere> _highPressureDelta = new HashSet<TileAtmosphere>(1000);
 
+        [ViewVariables]
+        private readonly List<IPipeNet> _pipeNets = new List<IPipeNet>();
+
+        /// <summary>
+        ///     Index of most recently updated <see cref="IPipeNet"/>.
+        /// </summary>
+        private int _pipeNetIndex = 0;
+
+        [ViewVariables]
+        private readonly List<PipeNetDeviceComponent> _pipeNetDevices = new List<PipeNetDeviceComponent>();
+
+        /// <summary>
+        ///     Index of most recently updated <see cref="PipeNetDeviceComponent"/>.
+        /// </summary>
+        private int _deviceIndex = 0;
+
         [ViewVariables]
         private ProcessState _state = ProcessState.TileEqualize;
 
@@ -84,6 +102,8 @@ namespace Content.Server.GameObjects.Components.Atmos
             HighPressureDelta,
             Hotspots,
             Superconductivity,
+            PipeNet,
+            PipeNetDevices,
         }
 
         /// <inheritdoc />
@@ -296,6 +316,28 @@ namespace Content.Server.GameObjects.Components.Atmos
             _excitedGroups.Remove(excitedGroup);
         }
 
+        public void AddPipeNet(IPipeNet pipeNet)
+        {
+            _pipeNets.Add(pipeNet);
+        }
+
+        public void RemovePipeNet(IPipeNet pipeNet)
+        {
+            _pipeNets.Remove(pipeNet);
+            _deviceIndex = 0;
+        }
+
+        public void AddPipeNetDevice(PipeNetDeviceComponent pipeNetDevice)
+        {
+            _pipeNetDevices.Add(pipeNetDevice);
+        }
+
+        public void RemovePipeNetDevice(PipeNetDeviceComponent pipeNetDevice)
+        {
+            _pipeNetDevices.Remove(pipeNetDevice);
+            _deviceIndex = 0;
+        }
+
         /// <inheritdoc />
         public TileAtmosphere? GetTile(GridCoordinates coordinates)
         {
@@ -401,6 +443,14 @@ namespace Content.Server.GameObjects.Components.Atmos
                     break;
                 case ProcessState.Superconductivity:
                     ProcessSuperconductivity();
+                    _state = ProcessState.PipeNet;
+                    break;
+                case ProcessState.PipeNet:
+                    ProcessPipeNets();
+                    _state = ProcessState.PipeNetDevices;
+                    break;
+                case ProcessState.PipeNetDevices:
+                    ProcessPipeNetDevices();
                     _state = ProcessState.TileEqualize;
                     break;
             }
@@ -520,6 +570,45 @@ namespace Content.Server.GameObjects.Components.Atmos
             }
         }
 
+        private void ProcessPipeNets()
+        {
+            _stopwatch.Restart();
+
+            var number = 0;
+            var pipeNets = _pipeNets.ToArray();
+            var netCount = pipeNets.Count();
+            for ( ; _pipeNetIndex < netCount; _pipeNetIndex++)
+            {
+                pipeNets[_pipeNetIndex].Update();
+
+                if (number++ < LagCheckIterations) continue;
+                number = 0;
+                // Process the rest next time.
+                if (_stopwatch.Elapsed.TotalMilliseconds >= LagCheckMaxMilliseconds)
+                    return;
+            }
+            _pipeNetIndex = 0;
+        }
+
+        private void ProcessPipeNetDevices()
+        {
+            _stopwatch.Restart();
+
+            var number = 0;
+            var pipeNetDevices = _pipeNetDevices.ToArray();
+            var deviceCount = pipeNetDevices.Count();
+            for ( ; _deviceIndex < deviceCount; _deviceIndex++)
+            {
+                pipeNetDevices[_deviceIndex].Update();
+
+                if (number++ < LagCheckIterations) continue;
+                number = 0;
+                // Process the rest next time.
+                if (_stopwatch.Elapsed.TotalMilliseconds >= LagCheckMaxMilliseconds)
+                    return;
+            }
+            _deviceIndex = 0;
+        }
         private AirtightComponent? GetObstructingComponent(MapIndices indices)
         {
             if (!Owner.TryGetComponent(out IMapGridComponent? mapGrid)) return default;

Content.Server/GameObjects/Components/Atmos/Piping/PipeNetDeviceComponent.cs

@@ -0,0 +1,50 @@
+using Content.Server.Atmos;
+using Content.Server.GameObjects.EntitySystems;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Log;
+
+namespace Content.Server.GameObjects.Components.Atmos.Piping
+{
+    /// <summary>
+    ///     Adds itself to a <see cref="IGridAtmosphereComponent"/> to be updated by.
+    ///     TODO: Make compatible with unanchoring/anchoring. Currently assumes that the Owner does not move.
+    /// </summary>
+    public abstract class PipeNetDeviceComponent : Component
+    {
+        public abstract void Update();
+
+        protected IGridAtmosphereComponent JoinedGridAtmos { get; private set; }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            JoinGridAtmos();
+        }
+
+        public override void OnRemove()
+        {
+            base.OnRemove();
+            LeaveGridAtmos();
+        }
+
+        private void JoinGridAtmos()
+        {
+            var gridAtmos = EntitySystem.Get<AtmosphereSystem>()
+                .GetGridAtmosphere(Owner.Transform.GridID);
+            if (gridAtmos == null)
+            {
+                Logger.Error($"{nameof(PipeNetDeviceComponent)} on entity {Owner.Uid} could not find an {nameof(IGridAtmosphereComponent)}.");
+                return;
+            }
+            JoinedGridAtmos = gridAtmos;
+            JoinedGridAtmos.AddPipeNetDevice(this);
+        }
+
+        private void LeaveGridAtmos()
+        {
+            JoinedGridAtmos?.RemovePipeNetDevice(this);
+            JoinedGridAtmos = null;
+        }
+    }
+}

Content.Server/GameObjects/Components/Atmos/Piping/Pumps/BasePumpComponent.cs

@@ -0,0 +1,68 @@
+using Content.Server.Atmos;
+using Content.Server.GameObjects.Components.NodeContainer;
+using Content.Server.GameObjects.Components.NodeContainer.Nodes;
+using Robust.Shared.Log;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+using System.Linq;
+
+namespace Content.Server.GameObjects.Components.Atmos.Piping
+{
+    /// <summary>
+    ///     Transfer gas from one <see cref="PipeNode"/> to another.
+    /// </summary>
+    public abstract class BasePumpComponent : PipeNetDeviceComponent
+    {
+        /// <summary>
+        ///     Needs to be same <see cref="PipeDirection"/> as that of a <see cref="Pipe"/> on this entity.
+        /// </summary>
+        [ViewVariables]
+        private PipeDirection _inletDirection;
+
+        /// <summary>
+        ///     Needs to be same <see cref="PipeDirection"/> as that of a <see cref="Pipe"/> on this entity.
+        /// </summary>
+        [ViewVariables]
+        private PipeDirection _outletDirection;
+
+        [ViewVariables]
+        private PipeNode _inletPipe;
+
+        [ViewVariables]
+        private PipeNode _outletPipe;
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+            serializer.DataField(ref _inletDirection, "inletDirection", PipeDirection.None);
+            serializer.DataField(ref _outletDirection, "outletDirection", PipeDirection.None);
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            if (!Owner.TryGetComponent<NodeContainerComponent>(out var container))
+            {
+                JoinedGridAtmos?.RemovePipeNetDevice(this);
+                Logger.Error($"{typeof(BasePumpComponent)} on entity {Owner.Uid} did not have a {nameof(NodeContainerComponent)}.");
+                return;
+            }
+            var pipeNodes = container.Nodes.OfType<PipeNode>();
+            _inletPipe = pipeNodes.Where(pipe => pipe.PipeDirection == _inletDirection).FirstOrDefault();
+            _outletPipe = pipeNodes.Where(pipe => pipe.PipeDirection == _outletDirection).FirstOrDefault();
+            if (_inletPipe == null | _outletPipe == null)
+            {
+                JoinedGridAtmos?.RemovePipeNetDevice(this);
+                Logger.Error($"{typeof(BasePumpComponent)} on entity {Owner.Uid} could not find compatible {nameof(PipeNode)}s on its {nameof(NodeContainerComponent)}.");
+                return;
+            }
+        }
+
+        public override void Update()
+        {
+            PumpGas(_inletPipe.Air, _outletPipe.Air);
+        }
+
+        protected abstract void PumpGas(GasMixture inletGas, GasMixture outletGas);
+    }
+}

Content.Server/GameObjects/Components/Atmos/Piping/Pumps/DebugPumpComponent.cs

@@ -0,0 +1,21 @@
+using Content.Server.Atmos;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.GameObjects.Components.Atmos.Piping
+{
+    /// <summary>
+    ///  Placeholder example of pump functionality.
+    /// </summary>
+    [RegisterComponent]
+    [ComponentReference(typeof(BasePumpComponent))]
+    public class DebugPumpComponent : BasePumpComponent
+    {
+        public override string Name => "DebugPump";
+
+        protected override void PumpGas(GasMixture inletGas, GasMixture outletGas)
+        {
+            outletGas.Merge(inletGas);
+            inletGas.Clear();
+        }
+    }
+}

Content.Server/GameObjects/Components/Atmos/Piping/Scrubbers/BaseSiphonComponent.cs

@@ -0,0 +1,52 @@
+using Content.Server.Atmos;
+using Content.Server.GameObjects.Components.NodeContainer;
+using Content.Server.GameObjects.Components.NodeContainer.Nodes;
+using Content.Server.GameObjects.EntitySystems;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Log;
+using Robust.Shared.ViewVariables;
+using System.Linq;
+
+namespace Content.Server.GameObjects.Components.Atmos.Piping
+{
+    /// <summary>
+    ///     Transfers gas from the tile it is on to a <see cref="PipeNode"/>.
+    /// </summary>
+    public abstract class BaseSiphonComponent : PipeNetDeviceComponent
+    {
+        [ViewVariables]
+        private PipeNode _scrubberOutlet;
+
+        private AtmosphereSystem _atmosSystem;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _atmosSystem = EntitySystem.Get<AtmosphereSystem>();
+            if (!Owner.TryGetComponent<NodeContainerComponent>(out var container))
+            {
+                JoinedGridAtmos?.RemovePipeNetDevice(this);
+                Logger.Error($"{typeof(BaseSiphonComponent)} on entity {Owner.Uid} did not have a {nameof(NodeContainerComponent)}.");
+                return;
+            }
+            _scrubberOutlet = container.Nodes.OfType<PipeNode>().FirstOrDefault();
+            if (_scrubberOutlet == null)
+            {
+                JoinedGridAtmos?.RemovePipeNetDevice(this);
+                Logger.Error($"{typeof(BaseSiphonComponent)} on entity {Owner.Uid} could not find compatible {nameof(PipeNode)}s on its {nameof(NodeContainerComponent)}.");
+                return;
+            }
+        }
+
+        public override void Update()
+        {
+            var tileAtmos = AtmosHelpers.GetTileAtmosphere(Owner.Transform.GridPosition);
+            if (tileAtmos == null)
+                return;
+            ScrubGas(tileAtmos.Air, _scrubberOutlet.Air);
+            _atmosSystem.GetGridAtmosphere(Owner.Transform.GridID).Invalidate(tileAtmos.GridIndices);
+        }
+
+        protected abstract void ScrubGas(GasMixture inletGas, GasMixture outletGas);
+    }
+}

Content.Server/GameObjects/Components/Atmos/Piping/Scrubbers/DebugSiphonComponent.cs

@@ -0,0 +1,21 @@
+using Content.Server.Atmos;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.GameObjects.Components.Atmos.Piping
+{
+    /// <summary>
+    ///     Placeholder example of scrubber functionality.
+    /// </summary>
+    [RegisterComponent]
+    [ComponentReference(typeof(BaseSiphonComponent))]
+    public class DebugSiphonComponent : BaseSiphonComponent
+    {
+        public override string Name => "DebugSiphon";
+
+        protected override void ScrubGas(GasMixture inletGas, GasMixture outletGas)
+        {
+            outletGas.Merge(inletGas);
+            inletGas.Clear();
+        }
+    }
+}

Content.Server/GameObjects/Components/Atmos/Piping/Vents/BaseVentComponent.cs

@@ -0,0 +1,54 @@
+using Content.Server.Atmos;
+using Content.Server.GameObjects.Components.NodeContainer;
+using Content.Server.GameObjects.Components.NodeContainer.Nodes;
+using Content.Server.GameObjects.EntitySystems;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.Log;
+using Robust.Shared.ViewVariables;
+using System.Linq;
+
+namespace Content.Server.GameObjects.Components.Atmos.Piping
+{
+    /// <summary>
+    ///     Transfers gas from a <see cref="PipeNode"/> to the tile it is on.
+    /// </summary>
+    public abstract class BaseVentComponent : PipeNetDeviceComponent
+    {
+        [ViewVariables]
+        private PipeNode _ventInlet;
+
+        private AtmosphereSystem _atmosSystem;
+
+
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _atmosSystem = EntitySystem.Get<AtmosphereSystem>();
+            if (!Owner.TryGetComponent<NodeContainerComponent>(out var container))
+            {
+                JoinedGridAtmos?.RemovePipeNetDevice(this);
+                Logger.Error($"{typeof(BaseVentComponent)} on entity {Owner.Uid} did not have a {nameof(NodeContainerComponent)}.");
+                return;
+            }
+            _ventInlet = container.Nodes.OfType<PipeNode>().FirstOrDefault();
+            if (_ventInlet == null)
+            {
+                JoinedGridAtmos?.RemovePipeNetDevice(this);
+                Logger.Error($"{typeof(BaseVentComponent)} on entity {Owner.Uid} could not find compatible {nameof(PipeNode)}s on its {nameof(NodeContainerComponent)}.");
+                return;
+            }
+        }
+
+        public override void Update()
+        {
+            var tileAtmos = AtmosHelpers.GetTileAtmosphere(Owner.Transform.GridPosition);
+            if (tileAtmos == null)
+                return;
+            VentGas(_ventInlet.Air, tileAtmos.Air);
+            _atmosSystem.GetGridAtmosphere(Owner.Transform.GridID).Invalidate(tileAtmos.GridIndices);
+        }
+
+        protected abstract void VentGas(GasMixture inletGas, GasMixture outletGas);
+    }
+}

Content.Server/GameObjects/Components/Atmos/Piping/Vents/DebugVentComponent.cs

@@ -0,0 +1,21 @@
+using Content.Server.Atmos;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.GameObjects.Components.Atmos.Piping
+{
+    /// <summary>
+    ///     Placeholder example of vent functionality.
+    /// </summary>
+    [RegisterComponent]
+    [ComponentReference(typeof(BaseVentComponent))]
+    public class DebugVentComponent : BaseVentComponent
+    {
+        public override string Name => "DebugVent";
+
+        protected override void VentGas(GasMixture inletGas, GasMixture outletGas)
+        {
+            outletGas.Merge(inletGas);
+            inletGas.Clear();
+        }
+    }
+}

Content.Server/GameObjects/Components/NodeContainer/NodeGroups/INodeGroup.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using Content.Server.GameObjects.Components.NodeContainer.Nodes;
 using Robust.Shared.IoC;
+using Robust.Shared.Map;
 using Robust.Shared.ViewVariables;
 
 namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
@@ -13,6 +14,8 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
     {
         IReadOnlyList<Node> Nodes { get; }
 
+        void Initialize(Node sourceNode);
+
         void AddNode(Node node);
 
         void RemoveNode(Node node);
@@ -34,6 +37,13 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
 
         public static readonly INodeGroup NullGroup = new NullNodeGroup();
 
+        protected GridId GridId { get; private set;}
+
+        public virtual void Initialize(Node sourceNode)
+        {
+            GridId = sourceNode.Owner.Transform.GridID;
+        }
+
         public void AddNode(Node node)
         {
             _nodes.Add(node);
@@ -54,6 +64,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
                 newGroup.CombineGroup(this);
                 return;
             }
+            OnGivingNodesForCombine(newGroup);
             foreach (var node in Nodes)
             {
                 node.NodeGroup = newGroup;
@@ -70,23 +81,31 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
             {
                 node.ClearNodeGroup();
             }
+            var newGroups = new List<INodeGroup>();
             foreach (var node in Nodes)
             {
                 if (node.TryAssignGroupIfNeeded())
                 {
                     node.SpreadGroup();
+                    newGroups.Add(node.NodeGroup);
                 }
             }
+            AfterRemake(newGroups);
         }
 
         protected virtual void OnAddNode(Node node) { }
         
         protected virtual void OnRemoveNode(Node node) { }
 
+        protected virtual void OnGivingNodesForCombine(INodeGroup newGroup) { }
+
+        protected virtual void AfterRemake(IEnumerable<INodeGroup> newGroups) { }
+
         private class NullNodeGroup : INodeGroup
         {
             public IReadOnlyList<Node> Nodes => _nodes;
             private readonly List<Node> _nodes = new List<Node>();
+            public void Initialize(Node sourceNode) { }
             public void AddNode(Node node) { }
             public void CombineGroup(INodeGroup newGroup) { }
             public void RemoveNode(Node node) { }

Content.Server/GameObjects/Components/NodeContainer/NodeGroups/IPipeNet.cs

@@ -0,0 +1,100 @@
+using Content.Server.Atmos;
+using Content.Server.GameObjects.Components.NodeContainer.Nodes;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces;
+using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.ViewVariables;
+using System.Collections.Generic;
+
+namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
+{
+    public interface IPipeNet : IGasMixtureHolder
+    {
+        /// <summary>
+        ///     Causes gas in the PipeNet to react.
+        /// </summary>
+        void Update();
+    }
+
+    [NodeGroup(NodeGroupID.Pipe)]
+    public class PipeNet : BaseNodeGroup, IPipeNet
+    {
+        [ViewVariables]
+        public GasMixture Air { get; set; } = new GasMixture();
+
+        public static readonly IPipeNet NullNet = new NullPipeNet();
+
+        [ViewVariables]
+        private readonly List<PipeNode> _pipes = new List<PipeNode>();
+
+        [ViewVariables]
+        private IGridAtmosphereComponent _gridAtmos;
+
+        public override void Initialize(Node sourceNode)
+        {
+            base.Initialize(sourceNode);
+            _gridAtmos = EntitySystem.Get<AtmosphereSystem>()
+                .GetGridAtmosphere(GridId);
+            _gridAtmos?.AddPipeNet(this);
+        }
+
+        public void Update()
+        {
+            Air.React(this);
+        }
+
+        protected override void OnAddNode(Node node)
+        {
+            if (!(node is PipeNode pipeNode))
+                return;
+            _pipes.Add(pipeNode);
+            pipeNode.JoinPipeNet(this);
+            Air.Volume += pipeNode.Volume;
+            Air.Merge(pipeNode.LocalAir);
+            pipeNode.LocalAir.Clear();
+        }
+
+        protected override void OnRemoveNode(Node node)
+        {
+            RemoveFromGridAtmos();
+            if (!(node is PipeNode pipeNode))
+                return;
+            var pipeAir = pipeNode.LocalAir;
+            pipeAir.Merge(Air);
+            pipeAir.Multiply(pipeNode.Volume / Air.Volume);
+            _pipes.Remove(pipeNode);
+        }
+
+        protected override void OnGivingNodesForCombine(INodeGroup newGroup)
+        {
+            if (!(newGroup is IPipeNet newPipeNet))
+                return;
+            newPipeNet.Air.Merge(Air);
+            Air.Clear();
+        }
+
+        protected override void AfterRemake(IEnumerable<INodeGroup> newGroups)
+        {
+            foreach (var newGroup in newGroups)
+            {
+                if (!(newGroup is IPipeNet newPipeNet))
+                    continue;
+                newPipeNet.Air.Merge(Air);
+                var newPipeNetGas = newPipeNet.Air;
+                newPipeNetGas.Multiply(newPipeNetGas.Volume / Air.Volume);
+            }
+            RemoveFromGridAtmos();
+        }
+
+        private void RemoveFromGridAtmos()
+        {
+            _gridAtmos.RemovePipeNet(this);
+        }
+
+        private class NullPipeNet : IPipeNet
+        {
+            GasMixture IGasMixtureHolder.Air { get; set; } = new GasMixture();
+            public void Update() { }
+        }
+    }
+}

Content.Server/GameObjects/Components/NodeContainer/NodeGroups/NodeGroupFactory.cs

@@ -1,8 +1,9 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
+using Content.Server.GameObjects.Components.NodeContainer.Nodes;
 using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.IoC;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
 
 namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
 {
@@ -17,7 +18,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
         /// <summary>
         ///     Returns a new <see cref="INodeGroup"/> instance.
         /// </summary>
-        INodeGroup MakeNodeGroup(NodeGroupID nodeGroupType);
+        INodeGroup MakeNodeGroup(Node sourceNode);
     }
 
     public class NodeGroupFactory : INodeGroupFactory
@@ -29,7 +30,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
 
         public void Initialize()
         {
-            var nodeGroupTypes = _reflectionManager.GetAllChildren<BaseNodeGroup>();
+            var nodeGroupTypes = _reflectionManager.GetAllChildren<INodeGroup>();
             foreach (var nodeGroupType in nodeGroupTypes)
             {
                 var att = nodeGroupType.GetCustomAttribute<NodeGroupAttribute>();
@@ -43,13 +44,15 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
             }
         }
 
-        public INodeGroup MakeNodeGroup(NodeGroupID nodeGroupType)
+        public INodeGroup MakeNodeGroup(Node sourceNode)
         {
-            if (_groupTypes.TryGetValue(nodeGroupType, out var type))
+            if (_groupTypes.TryGetValue(sourceNode.NodeGroupID, out var type))
             {
-                return _typeFactory.CreateInstance<INodeGroup>(type);
+                var nodeGroup = _typeFactory.CreateInstance<INodeGroup>(type);
+                nodeGroup.Initialize(sourceNode);
+                return nodeGroup;
             }
-            throw new ArgumentException($"{nodeGroupType} did not have an associated {nameof(INodeGroup)}.");
+            throw new ArgumentException($"{sourceNode.NodeGroupID} did not have an associated {nameof(INodeGroup)}.");
         }
     }
 
@@ -59,5 +62,6 @@ namespace Content.Server.GameObjects.Components.NodeContainer.NodeGroups
         HVPower,
         MVPower,
         Apc,
+        Pipe,
     }
 }

Content.Server/GameObjects/Components/NodeContainer/Nodes/Node.cs

@@ -53,7 +53,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
             serializer.DataField(this, x => NodeGroupID, "nodeGroupID", NodeGroupID.Default);
         }
 
-        public void Initialize(IEntity owner)
+        public virtual void Initialize(IEntity owner)
         {
             Owner = owner;
             _nodeGroupFactory = IoCManager.Resolve<INodeGroupFactory>();
@@ -143,7 +143,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
 
         private INodeGroup MakeNewGroup()
         {
-            return _nodeGroupFactory.MakeNodeGroup(NodeGroupID);
+            return _nodeGroupFactory.MakeNodeGroup(this);
         }
 
         private void AnchorUpdate()

Content.Server/GameObjects/Components/NodeContainer/Nodes/PipeNode.cs

@@ -0,0 +1,171 @@
+using Content.Server.Atmos;
+using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
+using Content.Server.Interfaces;
+using Content.Shared.Atmos;
+using Robust.Shared.GameObjects.Components.Transform;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Maths;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
+{
+    /// <summary>
+    ///     Connects with other <see cref="PipeNode"/>s whose <see cref="PipeNode.PipeDirection"/>
+    ///     correctly correspond.
+    /// </summary>
+    public class PipeNode : Node, IGasMixtureHolder
+    {
+        [ViewVariables]
+        public PipeDirection PipeDirection => _pipeDirection;
+        private PipeDirection _pipeDirection;
+
+        [ViewVariables]
+        private IPipeNet _pipeNet = PipeNet.NullNet;
+
+        [ViewVariables]
+        private bool _needsPipeNet = true;
+
+        /// <summary>
+        ///     The gases in this pipe.
+        /// </summary>
+        [ViewVariables]
+        public GasMixture Air
+        {
+            get => _needsPipeNet ? LocalAir : _pipeNet.Air;
+            set
+            {
+                if (_needsPipeNet)
+                    LocalAir = value;
+                else
+                    _pipeNet.Air = value;
+            }
+        }
+
+        /// <summary>
+        ///     Stores gas in this pipe when disconnected from a <see cref="IPipeNet"/>.
+        ///     Only for usage by <see cref="IPipeNet"/>s.
+        /// </summary>
+        [ViewVariables]
+        public GasMixture LocalAir { get; set; }
+
+        [ViewVariables]
+        public float Volume { get; private set; }
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+            serializer.DataField(ref _pipeDirection, "pipeDirection", PipeDirection.None);
+            serializer.DataField(this, x => Volume, "volume", 10);
+        }
+
+        public override void Initialize(IEntity owner)
+        {
+            base.Initialize(owner);
+            LocalAir = new GasMixture(Volume);
+        }
+
+        public void JoinPipeNet(IPipeNet pipeNet)
+        {
+            _pipeNet = pipeNet;
+            _needsPipeNet = false;
+        }
+
+        public void ClearPipeNet()
+        {
+            _pipeNet = PipeNet.NullNet;
+            _needsPipeNet = true;
+        }
+
+        protected override IEnumerable<Node> GetReachableNodes()
+        {
+            foreach (CardinalDirection direction in Enum.GetValues(typeof(CardinalDirection)))
+            {
+                PipeDirectionFromCardinal(direction, out var ownNeededConnection, out var theirNeededConnection);
+                if ((_pipeDirection & ownNeededConnection) == PipeDirection.None)
+                {
+                    continue;
+                }
+                var pipeNodesInDirection = Owner.GetComponent<SnapGridComponent>()
+                    .GetInDir((Direction) direction)
+                    .Select(entity => entity.TryGetComponent<NodeContainerComponent>(out var container) ? container : null)
+                    .Where(container => container != null)
+                    .SelectMany(container => container.Nodes)
+                    .OfType<PipeNode>()
+                    .Where(pipeNode => (pipeNode._pipeDirection & theirNeededConnection) != PipeDirection.None);
+                foreach (var pipeNode in pipeNodesInDirection)
+                {
+                    yield return pipeNode;
+                }
+            }
+        }
+
+        private void PipeDirectionFromCardinal(CardinalDirection direction, out PipeDirection sameDir, out PipeDirection oppDir)
+        {
+            switch (direction)
+            {
+                case CardinalDirection.North:
+                    sameDir = PipeDirection.North;
+                    oppDir = PipeDirection.South;
+                    break;
+                case CardinalDirection.South:
+                    sameDir = PipeDirection.South;
+                    oppDir = PipeDirection.North;
+                    break;
+                case CardinalDirection.East:
+                    sameDir = PipeDirection.East;
+                    oppDir = PipeDirection.West;
+                    break;
+                case CardinalDirection.West:
+                    sameDir = PipeDirection.West;
+                    oppDir = PipeDirection.East;
+                    break;
+                default:
+                    throw new ArgumentException("Invalid Direction.");
+            }
+        }
+
+        private enum CardinalDirection
+        {
+            North = Direction.North,
+            South = Direction.South,
+            East = Direction.East,
+            West = Direction.West,
+        }
+    }
+
+    public enum PipeDirection
+    {
+        None = 0,
+
+        //Half of a pipe in a direction
+        North = 1 << 0,
+        South = 1 << 1,
+        West = 1 << 2,
+        East = 1 << 3,
+
+        //Straight pipes
+        Longitudinal = North | South,
+        Lateral = West | East,
+
+        //Bends
+        NWBend = North | West,
+        NEBend = North | East,
+        SWBend = South | West,
+        SEBend = South | East,
+
+        //T-Junctions
+        TNorth = North | Lateral,
+        TSouth = South | Lateral,
+        TWest = West | Longitudinal,
+        TEast = East | Longitudinal,
+
+        //Four way
+        FourWay = North | South | East | West,
+
+        All = -1,
+    }
+}

Resources/Prototypes/Entities/Constructible/Ground/pipes.yml

@@ -0,0 +1,43 @@
+- type: entity
+  abstract: true
+  id: PipeBase
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Collidable
+  - type: SnapGrid
+    offset: Center
+  - type: Icon
+    texture: Constructible/Power/eightdirwire.png
+  - type: Sprite
+    sprite: Constructible/Power/hv_cable.rsi
+  - type: Destructible
+    thresholdvalue: 100
+
+- type: entity
+  parent: PipeBase
+  id: FourwayPipe
+  name: Fourway Pipe
+  components:
+  - type: Sprite
+    state: hvcable_15
+  - type: NodeContainer
+    nodes:
+    - !type:PipeNode
+      nodeGroupID: Pipe
+      pipeDirection: FourWay
+
+- type: entity
+  parent: PipeBase
+  id: LongitudinalPipe
+  name: Longitudinal Pipe
+  components:
+  - type: Sprite
+    state: hvcable_3
+  - type: NodeContainer
+    nodes:
+    - !type:PipeNode
+      nodeGroupID: Pipe
+      pipeDirection: Longitudinal

Resources/Prototypes/Entities/Constructible/Ground/pumps.yml

@@ -0,0 +1,36 @@
+- type: entity
+  abstract: true
+  id: PumpBase
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Collidable
+  - type: SnapGrid
+    offset: Center
+  - type: Icon
+    texture: Constructible/Power/eightdirwire.png
+  - type: Sprite
+    sprite: Constructible/Power/mv_cable.rsi
+  - type: Destructible
+    thresholdvalue: 100
+
+- type: entity
+  parent: PumpBase
+  id: NorthFromSouthPipePump
+  name: North from south pipe pump
+  components:
+  - type: Sprite
+    state: mvcable_3
+  - type: NodeContainer
+    nodes:
+    - !type:PipeNode
+      nodeGroupID: Pipe
+      pipeDirection: North
+    - !type:PipeNode
+      nodeGroupID: Pipe
+      pipeDirection: South
+  - type: DebugPump
+    outletDirection: North
+    inletDirection: South

Resources/Prototypes/Entities/Constructible/Ground/scrubbers.yml

@@ -0,0 +1,30 @@
+- type: entity
+  abstract: true
+  id: ScrubberBase
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Collidable
+  - type: SnapGrid
+    offset: Center
+  - type: Icon
+    texture: Constructible/Power/eightdirwire.png
+  - type: Sprite
+    texture: Constructible/Power/eightdirwire.png
+  - type: Destructible
+    thresholdvalue: 100
+
+- type: entity
+  parent: ScrubberBase
+  id: FromSouthScrubber
+  name: From South Scrubber
+  components:
+  - type: NodeContainer
+    nodes:
+    - !type:PipeNode
+      nodeGroID: Pipe
+      pipeDirection: South
+  - type: DebugSiphon
+    scrubberOutletDirection: South

Resources/Prototypes/Entities/Constructible/Ground/vents.yml

@@ -0,0 +1,30 @@
+- type: entity
+  abstract: true
+  id: VentBase
+  placement:
+    mode: SnapgridCenter
+  components:
+  - type: Clickable
+  - type: InteractionOutline
+  - type: Collidable
+  - type: SnapGrid
+    offset: Center
+  - type: Icon
+    texture: Constructible/Power/eightdirwire.png
+  - type: Sprite
+    texture: Constructible/Power/eightdirwire.png
+  - type: Destructible
+    thresholdvalue: 100
+
+- type: entity
+  parent: VentBase
+  id: FromSouthVent
+  name: From South Vent
+  components:
+  - type: NodeContainer
+    nodes:
+    - !type:PipeNode
+      nodeGroupID: Pipe
+      pipeDirection: South
+  - type: DebugVent
+    ventInletDirection: South