Pipe visualizers (#3042)

* modifies pipe sprites to look not connected

* pipe connector sprites

* PipeConnectorVisualizer

* Remove pipe visualizer

* Revert "Remove pipe visualizer"

This reverts commit dc8da93f99f20aa55247c6a94d26c7a75a3d1782.

* PipeDirection can be set with the sprite updating correctly

* fixes meta files

* removes unused vent/scrubber directions

* OnConnectedDirectionsNeedsUpdating

* comments + OnConnectedDirectionsNeedsUpdating gets called

* fix connecteddirections bug

* Combines ConnectedDirections sent to visualizer

* fixes unconnected pipe sprites

* Adds PipeConnectorVisualizer to other piping entities

* code cleanup

* Fixed bug with ConnectedDirections not being set correctly

* diff fix

* rotation simplification

* Improves rsi serialization

* enable nullable

* wip

* visualizer cleanup

* nullable cleanup

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

Content.Client/GameObjects/Components/Atmos/Piping/PipeConnectorVisualizer.cs

@@ -0,0 +1,86 @@
+#nullable enable
+using System;
+using Content.Shared.GameObjects.Components.Atmos;
+using JetBrains.Annotations;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Serialization;
+using YamlDotNet.RepresentationModel;
+
+namespace Content.Client.GameObjects.Components.Atmos
+{
+    [UsedImplicitly]
+    public class PipeConnectorVisualizer : AppearanceVisualizer
+    {
+        private string _baseState = string.Empty;
+
+        private RSI? _connectorRsi;
+
+        public override void LoadData(YamlMappingNode node)
+        {
+            base.LoadData(node);
+            var serializer = YamlObjectSerializer.NewReader(node);
+
+            serializer.DataField(ref _baseState, "baseState", "pipeConnector");
+
+            var rsiString = SharedSpriteComponent.TextureRoot / serializer.ReadDataField("rsi", "Constructible/Atmos/pipe.rsi");
+            var resourceCache = IoCManager.Resolve<IResourceCache>();
+            if (resourceCache.TryGetResource(rsiString, out RSIResource? rsi))
+                _connectorRsi = rsi.RSI;
+            else
+                Logger.Error($"{nameof(PipeVisualizer)} could not load to load RSI {rsiString}.");
+        }
+
+        public override void InitializeEntity(IEntity entity)
+        {
+            base.InitializeEntity(entity);
+
+            if (!entity.TryGetComponent<ISpriteComponent>(out var sprite))
+                return;
+
+            if (_connectorRsi == null)
+                return;
+
+            foreach (Layer layerKey in Enum.GetValues(typeof(Layer)))
+            {
+                sprite.LayerMapReserveBlank(layerKey);
+                var layer = sprite.LayerMapGet(layerKey);
+                sprite.LayerSetRSI(layer, _connectorRsi);
+                var layerState = _baseState + ((PipeDirection) layerKey).ToString();
+                sprite.LayerSetState(layer, layerState);
+            }
+        }
+
+        public override void OnChangeData(AppearanceComponent component)
+        {
+            base.OnChangeData(component);
+
+            if (!component.Owner.TryGetComponent<ISpriteComponent>(out var sprite))
+                return;
+
+            if (!component.TryGetData(PipeVisuals.VisualState, out PipeVisualState state))
+                return;
+
+            foreach (Layer layerKey in Enum.GetValues(typeof(Layer)))
+            {
+                var dir = (PipeDirection) layerKey;
+                var layerVisible = state.ConnectedDirections.HasDirection(dir);
+
+                var layer = sprite.LayerMapGet(layerKey);
+                sprite.LayerSetVisible(layer, layerVisible);
+            }
+        }
+
+        private enum Layer : byte
+        {
+            NorthConnection = PipeDirection.North,
+            SouthConnection = PipeDirection.South,
+            EastConnection = PipeDirection.East,
+            WestConnection = PipeDirection.West,
+        }
+    }
+}

Content.Client/GameObjects/Components/Atmos/Piping/PipeVisualizer.cs

@@ -1,4 +1,4 @@
-using System;
+#nullable enable
 using Content.Shared.GameObjects.Components.Atmos;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
@@ -12,47 +12,44 @@ using YamlDotNet.RepresentationModel;
 
 namespace Content.Client.GameObjects.Components.Atmos
 {
+    /// <summary>
+    ///     Sets the state of the sprite based on what shape of pipe it is.
+    /// </summary>
     [UsedImplicitly]
     public class PipeVisualizer : AppearanceVisualizer
     {
-        private string _rsiString;
+        private RSI? _pipeRSI;
-
-        private RSI _pipeRSI;
 
         public override void LoadData(YamlMappingNode node)
         {
             base.LoadData(node);
-
             var serializer = YamlObjectSerializer.NewReader(node);
-            serializer.DataField(ref _rsiString, "rsiString", "Constructible/Atmos/pipe.rsi");
+    
-
+            var rsiString = SharedSpriteComponent.TextureRoot / serializer.ReadDataField("rsi", "Constructible/Atmos/pipe.rsi");
-            var rsiPath = SharedSpriteComponent.TextureRoot / _rsiString;
+            var resourceCache = IoCManager.Resolve<IResourceCache>();
-            try
+            if (resourceCache.TryGetResource(rsiString, out RSIResource? rsi))
-            {
+                _pipeRSI = rsi.RSI;
-                var resourceCache = IoCManager.Resolve<IResourceCache>();
+            else
-                var resource = resourceCache.GetResource<RSIResource>(rsiPath);
+                Logger.Error($"{nameof(PipeVisualizer)} could not load to load RSI {rsiString}.");
-                _pipeRSI = resource.RSI;
-            }
-            catch (Exception e)
-            {
-                Logger.ErrorS("go.ventvisualizer", "Unable to load RSI '{0}'. Trace:\n{1}", rsiPath, e);
-            }
         }
 
         public override void InitializeEntity(IEntity entity)
         {
             base.InitializeEntity(entity);
-            if (!entity.TryGetComponent(out ISpriteComponent sprite)) return;
+            if (!entity.TryGetComponent<ISpriteComponent>(out var sprite)) return;
             sprite.LayerMapReserveBlank(Layer.PipeBase);
             var pipeBaseLayer = sprite.LayerMapGet(Layer.PipeBase);
-            sprite.LayerSetRSI(pipeBaseLayer, _pipeRSI);
+
+            if (_pipeRSI != null)
+                sprite.LayerSetRSI(pipeBaseLayer, _pipeRSI);
+
             sprite.LayerSetVisible(pipeBaseLayer, true);
         }
 
         public override void OnChangeData(AppearanceComponent component)
         {
             base.OnChangeData(component);
-            if (!component.Owner.TryGetComponent(out ISpriteComponent sprite)) return;
+            if (!component.Owner.TryGetComponent<ISpriteComponent>(out var sprite)) return;
             if (!component.TryGetData(PipeVisuals.VisualState, out PipeVisualState pipeVisualState)) return;
             var pipeBase = sprite.LayerMapGet(Layer.PipeBase);
             var pipeBaseStateId = GetPipeBaseStateId(pipeVisualState);
@@ -62,7 +59,7 @@ namespace Content.Client.GameObjects.Components.Atmos
         private string GetPipeBaseStateId(PipeVisualState pipeVisualState)
         {
             var stateId = "pipe";
-            stateId += pipeVisualState.PipeDirection.PipeDirectionToPipeShape().ToString();
+            stateId += pipeVisualState.PipeShape.ToString();
             return stateId;
         }
 

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

@@ -36,7 +36,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
         /// <summary>
         ///     If this node should be considered for connection by other nodes.
         /// </summary>
-        private bool Connectable => !_deleting && Anchored;
+        public bool Connectable => !_deleting && Anchored;
 
         private bool Anchored => !Owner.TryGetComponent<IPhysicsComponent>(out var physics) || physics.Anchored;
 
@@ -55,7 +55,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
             Owner = owner;
         }
 
-        public void OnContainerStartup()
+        public virtual void OnContainerStartup()
         {
             TryAssignGroupIfNeeded();
             CombineGroupWithReachable();
@@ -82,7 +82,7 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
             }
         }
 
-        public void OnContainerRemove()
+        public virtual void OnContainerRemove()
         {
             _deleting = true;
             NodeGroup.RemoveNode(this);

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

@@ -1,3 +1,4 @@
+#nullable enable
 using System.Collections.Generic;
 using Content.Server.Atmos;
 using Content.Server.GameObjects.Components.NodeContainer.NodeGroups;
@@ -5,27 +6,59 @@ using Content.Server.Interfaces;
 using Content.Shared.GameObjects.Components.Atmos;
 using Robust.Server.GameObjects;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Maths;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
 
 namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
 {
     /// <summary>
-    ///     Connects with other <see cref="PipeNode"/>s whose <see cref="PipeNode.PipeDirection"/>
+    ///     Connects with other <see cref="PipeNode"/>s whose <see cref="PipeDirection"/>
     ///     correctly correspond.
     /// </summary>
     public class PipeNode : Node, IGasMixtureHolder, IRotatableNode
     {
-        [ViewVariables]
+        /// <summary>
-        public PipeDirection PipeDirection { get => _pipeDirection; set => SetPipeDirection(value); }
+        ///     Modifies the <see cref="PipeDirection"/> of this pipe, and ensures the sprite is correctly rotated.
-        private PipeDirection _pipeDirection;
+        ///     This is a property for the sake of calling the method via ViewVariables.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public PipeDirection SetPipeDirectionAndSprite { get => PipeDirection; set => AdjustPipeDirectionAndSprite(value); }
 
+        /// <summary>
+        ///     The directions in which this pipe can connect to other pipes around it.
+        ///     Used to check if this pipe can connect to another pipe in a given direction.
+        /// </summary>
+        [ViewVariables]
+        public PipeDirection PipeDirection { get; private set; }
+
+        /// <summary>
+        ///     The directions in which this node is connected to other nodes.
+        ///     Used by <see cref="PipeVisualState"/>.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        private PipeDirection ConnectedDirections { get => _connectedDirections; set { _connectedDirections = value; UpdateAppearance(); } }
+        private PipeDirection _connectedDirections;
+
+        /// <summary>
+        ///     The <see cref="IPipeNet"/> this pipe is a part of. Set to <see cref="PipeNet.NullNet"/> when not in an <see cref="IPipeNet"/>.
+        /// </summary>
         [ViewVariables]
         private IPipeNet _pipeNet = PipeNet.NullNet;
 
+        /// <summary>
+        ///     If <see cref="_pipeNet"/> is set to <see cref="PipeNet.NullNet"/>.
+        ///     When true, this pipe may be storing gas in <see cref="LocalAir"/>.
+        /// </summary>
         [ViewVariables]
         private bool _needsPipeNet = true;
 
+        /// <summary>
+        ///     Prevents rotation events from re-calculating the <see cref="IPipeNet"/>.
+        ///     Used while rotating the sprite to the correct orientation while not affecting the pipe.
+        /// </summary>
+        private bool IgnoreRotation { get; set; }
+
         /// <summary>
         ///     The gases in this pipe.
         /// </summary>
@@ -47,19 +80,19 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
         ///     Only for usage by <see cref="IPipeNet"/>s.
         /// </summary>
         [ViewVariables]
-        public GasMixture LocalAir { get; set; }
+        public GasMixture LocalAir { get; set; } = default!;
 
         [ViewVariables]
         public float Volume => LocalAir.Volume;
 
-        private AppearanceComponent _appearance;
+        private AppearanceComponent? _appearance;
 
         private const float DefaultVolume = 1;
 
         public override void ExposeData(ObjectSerializer serializer)
         {
             base.ExposeData(serializer);
-            serializer.DataField(ref _pipeDirection, "pipeDirection", PipeDirection.None);
+            serializer.DataField(this, x => x.PipeDirection, "pipeDirection", PipeDirection.None);
             serializer.DataField(this, x => x.LocalAir, "gasMixture", new GasMixture(DefaultVolume));
         }
 
@@ -67,9 +100,21 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
         {
             base.Initialize(owner);
             Owner.TryGetComponent(out _appearance);
+        }
+
+        public override void OnContainerStartup()
+        {
+            base.OnContainerStartup();
+            OnConnectedDirectionsNeedsUpdating();
             UpdateAppearance();
         }
 
+        public override void OnContainerRemove()
+        {
+            base.OnContainerRemove();
+            UpdateAdjacentConnectedDirections();
+        }
+
         public void JoinPipeNet(IPipeNet pipeNet)
         {
             _pipeNet = pipeNet;
@@ -82,61 +127,165 @@ namespace Content.Server.GameObjects.Components.NodeContainer.Nodes
             _needsPipeNet = true;
         }
 
+        /// <summary>
+        ///     Rotates the <see cref="PipeDirection"/> when the entity is rotated, and re-calculates the <see cref="IPipeNet"/>.
+        /// </summary>
         void IRotatableNode.RotateEvent(RotateEvent ev)
         {
+            if (IgnoreRotation)
+                return;
+
             var diff = ev.NewRotation - ev.OldRotation;
             PipeDirection = PipeDirection.RotatePipeDirection(diff);
+            RefreshNodeGroup();
+            OnConnectedDirectionsNeedsUpdating();
+            UpdateAppearance();
         }
 
         protected override IEnumerable<Node> GetReachableNodes()
         {
             for (var i = 0; i < PipeDirectionHelpers.PipeDirections; i++)
             {
-                var pipeDirection = (PipeDirection) (1 << i);
+                var pipeDir = (PipeDirection) (1 << i);
 
-                var ownNeededConnection = pipeDirection;
+                if (!PipeDirection.HasDirection(pipeDir))
-                var theirNeededConnection = ownNeededConnection.GetOpposite();
-                if (!_pipeDirection.HasDirection(ownNeededConnection))
-                {
                     continue;
-                }
 
-                var pipeNodesInDirection = new List<PipeNode>();
+                foreach (var pipe in LinkableNodesInDirection(pipeDir))
+                    yield return pipe;
+            }
+        }
 
-                var entities = Owner.GetComponent<SnapGridComponent>()
+        /// <summary>
-                    .GetInDir(pipeDirection.ToDirection());
+        ///     Gets the pipes that can connect to us from entities on the tile adjacent in a direction.
+        /// </summary>
+        private IEnumerable<PipeNode> LinkableNodesInDirection(PipeDirection pipeDir)
+        {
+            foreach (var pipe in PipesInDirection(pipeDir))
+            {
+                if (pipe.PipeDirection.HasDirection(pipeDir.GetOpposite()))
+                    yield return pipe;
+            }
+        }
 
-                foreach (var entity in entities)
+        /// <summary>
+        ///     Gets the pipes from entities on the tile adjacent in a direction.
+        /// </summary>
+        private IEnumerable<PipeNode> PipesInDirection(PipeDirection pipeDir)
+        {
+            var entities = Owner.GetComponent<SnapGridComponent>()
+                .GetInDir(pipeDir.ToDirection());
+
+            foreach (var entity in entities)
+            {
+                if (!entity.TryGetComponent<NodeContainerComponent>(out var container))
+                    continue;
+
+                foreach (var node in container.Nodes)
                 {
-                    if (entity.TryGetComponent<NodeContainerComponent>(out var container))
+                    if (node is PipeNode pipe)
-                    {
+                        yield return pipe;
-                        foreach (var node in container.Nodes)
-                        {
-                            if (node is PipeNode pipeNode && pipeNode._pipeDirection.HasDirection(theirNeededConnection))
-                            {
-                                pipeNodesInDirection.Add(pipeNode);
-                            }
-                        }
-                    }
-                }
-
-                foreach (var pipeNode in pipeNodesInDirection)
-                {
-                    yield return pipeNode;
                 }
             }
         }
 
-        private void UpdateAppearance()
+        /// <summary>
+        ///     Updates the <see cref="ConnectedDirections"/> of this and all sorrounding pipes.
+        /// </summary>
+        private void OnConnectedDirectionsNeedsUpdating()
         {
-            _appearance?.SetData(PipeVisuals.VisualState, new PipeVisualState(PipeDirection));
+            UpdateConnectedDirections();
+            UpdateAdjacentConnectedDirections();
         }
 
-        private void SetPipeDirection(PipeDirection pipeDirection)
+        /// <summary>
+        ///     Checks what directions there are connectable pipes in, to update <see cref="ConnectedDirections"/>.
+        /// </summary>
+        private void UpdateConnectedDirections()
         {
-            _pipeDirection = pipeDirection;
+            ConnectedDirections = PipeDirection.None;
+            for (var i = 0; i < PipeDirectionHelpers.PipeDirections; i++)
+            {
+                var pipeDir = (PipeDirection) (1 << i);
+
+                if (!PipeDirection.HasDirection(pipeDir))
+                    continue;
+
+                foreach (var pipe in LinkableNodesInDirection(pipeDir))
+                {
+                    if (pipe.Connectable && pipe.NodeGroupID == NodeGroupID)
+                    {
+                        ConnectedDirections |= pipeDir;
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Calls <see cref="UpdateConnectedDirections"/> on all adjacent pipes,
+        ///     to update their <see cref="ConnectedDirections"/> when this pipe is changed.
+        /// </summary>
+        private void UpdateAdjacentConnectedDirections()
+        {
+            for (var i = 0; i < PipeDirectionHelpers.PipeDirections; i++)
+            {
+                var pipeDir = (PipeDirection) (1 << i);
+                foreach (var pipe in LinkableNodesInDirection(pipeDir))
+                    pipe.UpdateConnectedDirections();
+            }
+        }
+
+        /// <summary>
+        ///     Updates the <see cref="AppearanceComponent"/>.
+        ///     Gets the combined <see cref="ConnectedDirections"/> of every pipe on this entity, so the visualizer on this entity can draw the pipe connections.
+        /// </summary>
+        private void UpdateAppearance()
+        {
+            var netConnectedDirections = PipeDirection.None;
+            if (Owner.TryGetComponent<NodeContainerComponent>(out var container))
+            {
+                foreach (var node in container.Nodes)
+                {
+                    if (node is PipeNode pipe)
+                    {
+                        netConnectedDirections |= pipe.ConnectedDirections;
+                    }
+                }
+            }
+
+            _appearance?.SetData(PipeVisuals.VisualState, new PipeVisualState(PipeDirection.PipeDirectionToPipeShape(), netConnectedDirections));
+        }
+
+        /// <summary>
+        ///     Changes the directions of this pipe while ensuring the sprite is correctly rotated.
+        /// </summary>
+        public void AdjustPipeDirectionAndSprite(PipeDirection newDir)
+        {
+            IgnoreRotation = true;
+
+            var baseDir = newDir.PipeDirectionToPipeShape().ToBaseDirection();
+
+            var newAngle = Angle.FromDegrees(0);
+
+            for (var i = 0; i < PipeDirectionHelpers.PipeDirections; i++)
+            {
+                var pipeDir = (PipeDirection) (1 << i);
+                var angle = pipeDir.ToAngle();
+                if (baseDir.RotatePipeDirection(angle) == newDir) //finds what angle the entity needs to be rotated from the base to be set to the correct direction
+                {
+                    newAngle = angle;
+                    break;
+                }
+            }
+
+            Owner.Transform.LocalRotation = newAngle; //rotate the entity so the sprite's new state will be of the correct direction
+            PipeDirection = newDir;
+
             RefreshNodeGroup();
+            OnConnectedDirectionsNeedsUpdating();
             UpdateAppearance();
+            IgnoreRotation = false;
         }
     }
 }

Content.Shared/GameObjects/Components/Atmos/SharedPipeComponent.cs

@@ -13,15 +13,19 @@ namespace Content.Shared.GameObjects.Components.Atmos
     [Serializable, NetSerializable]
     public class PipeVisualState
     {
-        public readonly PipeDirection PipeDirection;
+        public readonly PipeShape PipeShape;
 
-        public PipeVisualState(PipeDirection pipeDirection)
+        public readonly PipeDirection ConnectedDirections;
+
+        public PipeVisualState(PipeShape pipeShape, PipeDirection connectedDirections)
         {
-            PipeDirection = pipeDirection;
+            PipeShape = pipeShape;
+            ConnectedDirections = connectedDirections;
         }
     }
 
     [Flags]
+    [Serializable, NetSerializable]
     public enum PipeDirection
     {
         None = 0,
@@ -63,6 +67,25 @@ namespace Content.Shared.GameObjects.Components.Atmos
         Fourway
     }
 
+    public static class PipeShapeHelpers
+    {
+        /// <summary>
+        ///     Gets the direction of a shape when facing 0 degrees (the initial direction of entities).
+        /// </summary>
+        public static PipeDirection ToBaseDirection(this PipeShape shape)
+        {
+            return shape switch
+            {
+                PipeShape.Half => PipeDirection.East,
+                PipeShape.Straight => PipeDirection.Lateral,
+                PipeShape.Bend => PipeDirection.SEBend,
+                PipeShape.TJunction => PipeDirection.TEast,
+                PipeShape.Fourway => PipeDirection.Fourway,
+                _ => throw new ArgumentOutOfRangeException(nameof(shape), $"{shape} does not have an associated {nameof(PipeDirection)}."),
+            };
+        }
+    }
+
     public static class PipeDirectionHelpers
     {
         public const int PipeDirections = 4;

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

@@ -16,6 +16,9 @@
     - sprite: Constructible/Atmos/pipe.rsi
       state: pipeHalf
     - state: gasCanisterPort
+  - type: Appearance
+    visuals:
+    - type: PipeConnectorVisualizer
   - type: Damageable
   - type: Destructible
     thresholds:

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

@@ -28,6 +28,7 @@
     - state: gasFilter
   - type: Appearance
     visuals:
+    - type: PipeConnectorVisualizer
     - type: GasFilterVisualizer
 
 - type: entity

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

@@ -25,6 +25,7 @@
   - type: Appearance
     visuals:
     - type: PipeVisualizer
+    - type: PipeConnectorVisualizer
   - type: Icon
     sprite: Constructible/Atmos/pipe.rsi
 
@@ -55,7 +56,7 @@
       pipeDirection: Lateral
   - type: Icon
     state: pipeStraight
-
+    
 - type: entity
   parent: PipeBase
   id: PipeBend
@@ -68,7 +69,7 @@
       pipeDirection: SEBend
   - type: Icon
     state: pipeBend
-
+    
 - type: entity
   parent: PipeBase
   id: PipeTJunction
@@ -81,7 +82,7 @@
       pipeDirection: TEast
   - type: Icon
     state: pipeTJunction
-
+    
 - type: entity
   parent: PipeBase
   id: PipeFourway
@@ -93,4 +94,4 @@
       nodeGroupID: Pipe
       pipeDirection: Fourway
   - type: Icon
-    state: pipeFourway
+    state: pipeFourway

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

@@ -28,6 +28,7 @@
     - state: pumpPressure
   - type: Appearance
     visuals:
+    - type: PipeConnectorVisualizer
     - type: PumpVisualizer
 
 - type: entity

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

@@ -28,6 +28,7 @@
     - state: scrubOff
   - type: Appearance
     visuals:
+    - type: PipeConnectorVisualizer
     - type: SiphonVisualizer
 
 - type: entity

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

@@ -28,6 +28,7 @@
     - state: ventOff
   - type: Appearance
     visuals:
+    - type: PipeConnectorVisualizer
     - type: VentVisualizer
 
 - type: entity

Resources/Textures/Constructible/Atmos/gascanisterport.rsi/meta.json

@@ -9,7 +9,6 @@
    "states":[
       {
          "name":"gasCanisterPort",
-         "directions":1
       }
    ]
 }

Resources/Textures/Constructible/Atmos/pipe.rsi/meta.json

@@ -21,11 +21,22 @@
       },
       {
          "name":"pipeFourway",
-         "directions":1
       },
       {
          "name":"pipeStraight",
          "directions":4
+      },
+      {
+         "name":"pipeConnectorSouth",
+      },
+      {
+         "name":"pipeConnectorNorth",
+      },
+      {
+         "name":"pipeConnectorEast",
+      },
+      {
+         "name":"pipeConnectorWest",
       }
    ]
 }

Resources/Textures/Constructible/Atmos/scrubber.rsi/meta.json

@@ -9,11 +9,9 @@
    "states":[
       {
          "name":"scrubOff",
-         "directions":4
       },
       {
          "name":"scrubOn",
-         "directions":1,
          "delays":[ [ 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08, 0.08 ] ]
       }
    ]

Resources/Textures/Constructible/Atmos/vent.rsi/meta.json

@@ -9,11 +9,9 @@
    "states":[
       {
          "name":"ventOff",
-         "directions":4
       },
       {
          "name":"ventOn",
-         "directions":1,
          "delays":[ [ 0.08, 0.08, 0.08, 0.08 ] ]
       }
    ]