diff --git a/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs b/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs index a669a8da4c1..eff37603a6a 100644 --- a/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs +++ b/Content.Client/Chemistry/UI/ChemMasterBoundUserInterface.cs @@ -56,6 +56,7 @@ protected override void Open() } _window.OnReagentButtonPressed += (args, button) => SendMessage(new ChemMasterReagentAmountButtonMessage(button.Id, button.Amount, button.IsBuffer)); + _window.OnToggleValveButtonPressed += () => SendMessage(new ChemMasterToggleValveMessage()); // Starlight-edit: Plumbing valve } /// diff --git a/Content.Client/Chemistry/UI/ChemMasterWindow.xaml b/Content.Client/Chemistry/UI/ChemMasterWindow.xaml index d67906f6b1a..2efa2be25b3 100644 --- a/Content.Client/Chemistry/UI/ChemMasterWindow.xaml +++ b/Content.Client/Chemistry/UI/ChemMasterWindow.xaml @@ -10,7 +10,10 @@ [DataField, ViewVariables(VVAccess.ReadWrite)] public bool Deconstructable = true; + + // Starlight: RPLD + /// + /// Toggles whether this entity is deconstructable by the RPLD (plumbing) or not + /// + [DataField("rpld"), ViewVariables(VVAccess.ReadWrite)] + public bool RpldDeconstructable = false; + // Starlight End: RPLD } diff --git a/Content.Shared/RCD/RCDEvents.cs b/Content.Shared/RCD/RCDEvents.cs index 6871ec178ee..3e3651e2931 100644 --- a/Content.Shared/RCD/RCDEvents.cs +++ b/Content.Shared/RCD/RCDEvents.cs @@ -21,3 +21,17 @@ public enum RcdUiKey : byte { Key } + +// Starlight: RPLD +[Serializable, NetSerializable] +public sealed class RPDSelectedLayerEvent : EntityEventArgs +{ + public readonly NetEntity NetEntity; + public readonly byte Layer; + + public RPDSelectedLayerEvent(NetEntity netEntity, byte layer) + { + NetEntity = netEntity; + Layer = layer; + } +} diff --git a/Content.Shared/RCD/Systems/RCDSystem.cs b/Content.Shared/RCD/Systems/RCDSystem.cs index 8df22e171c3..02874a3a060 100644 --- a/Content.Shared/RCD/Systems/RCDSystem.cs +++ b/Content.Shared/RCD/Systems/RCDSystem.cs @@ -25,6 +25,8 @@ using Robust.Shared.Prototypes; using Robust.Shared.Serialization; using System.Linq; +using Content.Shared.Atmos.Components; +using Content.Shared.Hands.EntitySystems; using Robust.Shared.Audio; namespace Content.Shared.RCD.Systems; @@ -47,6 +49,7 @@ public sealed class RCDSystem : EntitySystem [Dependency] private readonly SharedMapSystem _mapSystem = default!; [Dependency] private readonly SharedTransformSystem _transform = default!; [Dependency] private readonly TagSystem _tags = default!; + [Dependency] private readonly SharedHandsSystem _hands = default!; // Starlight private readonly int _instantConstructionDelay = 0; private readonly EntProtoId _instantConstructionFx = "EffectRCDConstruct0"; @@ -67,11 +70,35 @@ public override void Initialize() SubscribeLocalEvent>(OnDoAfterAttempt); SubscribeLocalEvent(OnRCDSystemMessage); SubscribeNetworkEvent(OnRCDconstructionGhostRotationEvent); + SubscribeNetworkEvent(OnRPDSelectedLayerEvent); SubscribeLocalEvent(OnIdCardSwipeHappened); // Frontier } #region Event handling + // Starlight: RPLD + private void OnRPDSelectedLayerEvent(RPDSelectedLayerEvent ev, EntitySessionEventArgs session) + { + var uid = GetEntity(ev.NetEntity); + + if (session.SenderSession.AttachedEntity is not { } player) + return; + + if (_hands.GetActiveItem(player) != uid) + return; + + if (!TryComp(uid, out var rcd)) + return; + + var layerInt = Math.Clamp(ev.Layer, (byte) AtmosPipeLayer.Primary, (byte) AtmosPipeLayer.Tertiary); // HL: Replace with Quinary when we get 5 layers lol + var selectedLayer = (AtmosPipeLayer) layerInt; + + if (rcd.IsRPLD && selectedLayer > AtmosPipeLayer.Tertiary) + selectedLayer = AtmosPipeLayer.Tertiary; + + rcd.LastSelectedLayer = selectedLayer; + } + private void OnMapInit(EntityUid uid, RCDComponent component, MapInitEvent args) { SanitizeLinkedShuttle(uid, component); @@ -420,7 +447,7 @@ private void OnDoAfter(EntityUid uid, RCDComponent component, RCDDoAfterEvent ar } // Finalize the operation (this should handle prediction properly) - FinalizeRCDOperation(uid, component, gridUid, mapGrid, tile, position, args.Direction, args.Target, args.User); + FinalizeRCDOperation(uid, component, gridUid, mapGrid, tile, position, args.Direction, args.PipeLayer, args.Target, args.User); // Play audio and consume charges _audio.PlayPredicted(component.SuccessSound, uid, args.User); @@ -681,7 +708,7 @@ private bool IsDeconstructionStillValid(EntityUid uid, TileRef tile, EntityUid? else { // The object is not in the whitelist - if (!TryComp(target, out var deconstructible) || !deconstructible.Deconstructable) + if (!TryComp(target, out var deconstructible) || !deconstructible.Deconstructable || TryComp(uid, out var rcd) && !deconstructible.RpldDeconstructable && rcd.IsRPLD) // Starlight: RPLD { if (popMsgs) _popup.PopupClient(Loc.GetString("rcd-component-deconstruct-target-not-on-whitelist-message"), uid, user); @@ -697,7 +724,8 @@ private bool IsDeconstructionStillValid(EntityUid uid, TileRef tile, EntityUid? #region Entity construction/deconstruction - private void FinalizeRCDOperation(EntityUid uid, RCDComponent component, EntityUid gridUid, MapGridComponent mapGrid, TileRef tile, Vector2i position, Direction direction, EntityUid? target, EntityUid user) + // Starlight Edit: Add layer to finalize for deterministic layer placement. + private void FinalizeRCDOperation(EntityUid uid, RCDComponent component, EntityUid gridUid, MapGridComponent mapGrid, TileRef tile, Vector2i position, Direction direction, AtmosPipeLayer pipeLayer, EntityUid? target, EntityUid user) { if (!_net.IsServer) return; @@ -782,6 +810,9 @@ public sealed partial class RCDDoAfterEvent : DoAfterEvent [DataField] public Direction Direction { get; private set; } + [DataField] + public AtmosPipeLayer PipeLayer { get; private set; } = AtmosPipeLayer.Primary; // Starlight Edit: Layer snapshot captured at doafter start and replayed on finalize. + [DataField] public ProtoId StartingProtoId { get; private set; } diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingConnectorAppearanceComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingConnectorAppearanceComponent.cs new file mode 100644 index 00000000000..f830fdf4567 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingConnectorAppearanceComponent.cs @@ -0,0 +1,29 @@ +using Robust.Shared.Utility; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// Adds dynamic connector sprites to plumbing machines. +/// Shows jagged connectors where nodes exist and switches layer to smooth ends version when connected. +/// +[RegisterComponent] +public sealed partial class PlumbingConnectorAppearanceComponent : Component +{ + /// + /// Sprite for disconnected (jagged) connectors. + /// + [DataField] + public SpriteSpecifier.Rsi Disconnected = new(new("_Starlight/Structures/Piping/Plumbing/plumbers.rsi"), "ductConnector"); + + /// + /// Sprite for connected (smooth) connectors - overlays disconnected state. + /// + [DataField] + public SpriteSpecifier.Rsi Connected = new(new("_Starlight/Structures/Piping/Plumbing/plumbers.rsi"), "ductConnector_connected"); + + /// + /// Offset from center for connector sprites. Used so jagged ends stick out from under a machine to be visible under big sprites. + /// + [DataField] + public float Offset; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingInletComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInletComponent.cs new file mode 100644 index 00000000000..8ea89f63589 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInletComponent.cs @@ -0,0 +1,40 @@ +using Content.Shared.FixedPoint; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing inlet that pulls reagents from the network. +/// Actively pulls reagents from its inlet nodes each update tick into the specified solution. +/// Each inlet node connects to its own plumbing network, preventing network bridging +/// through multi-connector machines. +/// Other machines can pull from this entity via . +/// +[RegisterComponent] +public sealed partial class PlumbingInletComponent : Component +{ + /// + /// The name of the solution on this entity to pull reagents into. + /// + [DataField] + public string SolutionName = "tank"; + + /// + /// The names of the inlet nodes to pull from. + /// Each node should be a single-direction PlumbingNode so that each direction + /// has its own isolated network. + /// + [DataField] + public List InletNames = new() { "inlet" }; + + /// + /// Amount to transfer per update, shared across all inlets. + /// + [DataField] + public FixedPoint2 TransferAmount = FixedPoint2.New(20); + + /// + /// Round-robin indices for fair outlet selection. + /// Tracks which outlet to start from when pulling from multiple sources on each network. + /// + public Dictionary RoundRobinIndices = new(); +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingInputComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInputComponent.cs new file mode 100644 index 00000000000..6a78ab9ddcd --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingInputComponent.cs @@ -0,0 +1,16 @@ +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing input that players can pour reagents into using containers. +/// Paired with to allow other machines +/// to pull reagents from its solution via the plumbing network. +/// +[RegisterComponent] +public sealed partial class PlumbingInputComponent : Component +{ + /// + /// The name of the solution on this entity that receives input. + /// + [DataField] + public string SolutionName = "input"; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutletComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutletComponent.cs new file mode 100644 index 00000000000..9ad1ee8f915 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutletComponent.cs @@ -0,0 +1,48 @@ +using System.Collections.Generic; +using Robust.Shared.GameStates; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// Marks an entity as a reagent source on the plumbing network. +/// discovers entities with this component +/// when other machines request reagents from the network. +/// +[RegisterComponent, NetworkedComponent, AutoGenerateComponentState] +public sealed partial class PlumbingOutletComponent : Component +{ + /// + /// The name of the solution to provide to the network. + /// + [DataField] + public string SolutionName = "tank"; + + /// + /// The outlet node names that serve this solution. + /// Defaults to a single "outlet" node. Devices with multiple outlets + /// (e.g. the filter) can list several names. + /// + [DataField] + public List OutletNames = new() { "outlet" }; + + /// + /// If true, this outlet can be pulled from. If false, it's blocked. + /// + [DataField, AutoNetworkedField] + public bool Enabled = true; + + /// + /// If set, look for the solution on the entity in this container slot instead of on this entity. + /// Useful for machines like dispensers where the solution is in a beaker. + /// + [DataField] + public string? ContainerSlotId; + + /// + /// If true, configured outlet nodes on this machine are internally linked in the + /// plumbing graph, allowing attached duct networks to bridge through the machine. + /// Visual connector state and per-edge layer limits are unchanged. + /// + [DataField] + public bool ConnectedOutlets; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutputComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutputComponent.cs new file mode 100644 index 00000000000..2b2b639342f --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingOutputComponent.cs @@ -0,0 +1,15 @@ +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing output that players can draw reagents from using containers. +/// Pulling from the network is handled by . +/// +[RegisterComponent] +public sealed partial class PlumbingOutputComponent : Component +{ + /// + /// The name of the solution on this entity that players can draw from. + /// + [DataField] + public string SolutionName = "output"; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingPillPressComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingPillPressComponent.cs new file mode 100644 index 00000000000..16d6b3e247c --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingPillPressComponent.cs @@ -0,0 +1,100 @@ +using Content.Shared.FixedPoint; +using Robust.Shared.GameStates; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing pill press that automatically creates pills or patches +/// from reagents pulled through its inlet network. +/// When the buffer accumulates enough reagents to meet the dosage, +/// it spawns a pill or patch entity on the ground containing those reagents. +/// Supports optional mixing mode with two configurable ratio inlets (E/W) +/// in addition to the normal north inlet. +/// +[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)] +public sealed partial class PlumbingPillPressComponent : Component +{ + /// + /// Name of the buffer solution that holds incoming reagents. + /// + [DataField] + public string BufferSolutionName = "buffer"; + + /// + /// The dosage per pill/patch in units. Clamped 1–20. + /// + [DataField, AutoNetworkedField] + public uint Dosage = 10; + + /// + /// Whether we're producing pills or patches. + /// + [DataField, AutoNetworkedField] + public PillPressOutputMode OutputMode = PillPressOutputMode.Pill; + + /// + /// The pill visual type (0–19). Only relevant for pills. + /// + [DataField, AutoNetworkedField] + public uint PillType; + + /// + /// Label applied to created pills/patches. + /// + [DataField, AutoNetworkedField] + public string Label = string.Empty; + + /// + /// Whether the press is enabled and will pull/produce. + /// + [DataField, AutoNetworkedField] + public bool Enabled = true; + + // ========================================================================= + // Mixing mode fields + // ========================================================================= + + /// + /// Whether ratio-controlled mixing is active. + /// When enabled, E/W inlets pull proportionally into staging solutions + /// and combine into the buffer when targets are met. + /// + [DataField, AutoNetworkedField] + public bool MixingEnabled; + + /// + /// Ratio percentage for the east inlet (0–100). + /// + [DataField, AutoNetworkedField] + public float InletRatioEast; + + /// + /// Ratio percentage for the west inlet (0–100). + /// + [DataField, AutoNetworkedField] + public float InletRatioWest; + + /// + /// Name of the east staging solution. + /// + [DataField] + public string StagingEastSolutionName = "stagingEast"; + + /// + /// Name of the west staging solution. + /// + [DataField] + public string StagingWestSolutionName = "stagingWest"; + + /// + /// Node name for the east inlet. + /// + [DataField] + public string InletEastNodeName = "mixingInletEast"; + + /// + /// Node name for the west inlet. + /// + [DataField] + public string InletWestNodeName = "mixingInletWest"; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingReactorComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingReactorComponent.cs new file mode 100644 index 00000000000..21b509251df --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingReactorComponent.cs @@ -0,0 +1,67 @@ +using Content.Shared.Atmos; +using Content.Shared.Chemistry.Reagent; +using Content.Shared.FixedPoint; +using Robust.Shared.GameStates; +using Robust.Shared.Prototypes; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing reactor that accumulates reagents and triggers chemical reactions. +/// Pulls specific reagents from the inlet until target quantities are met, +/// then triggers reactions in the buffer at a configurable temperature. +/// Products are moved to an output solution for other machines to pull. +/// +[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)] +public sealed partial class PlumbingReactorComponent : Component +{ + /// + /// Name of the inlet node for pulling reagents from the network. + /// + [DataField] + public string InletName = "inlet"; + + /// + /// Name of the buffer solution that holds reagents waiting to react. + /// + [DataField] + public string BufferSolutionName = "buffer"; + + /// + /// Name of the output solution that holds reacted products. + /// + [DataField] + public string OutputSolutionName = "output"; + + /// + /// Amount to pull from tanks per update. + /// + [DataField] + public FixedPoint2 TransferAmount = FixedPoint2.New(20); + + /// + /// Whether the reactor is currently enabled. + /// + [DataField, AutoNetworkedField] + public bool Enabled = true; + + /// + /// The reagent targets to accumulate. Key is reagent prototype ID, value is target quantity. + /// When all targets are met, the buffer triggers reactions and moves products to output. + /// + [DataField, AutoNetworkedField] + public Dictionary, FixedPoint2> ReagentTargets = new(); + + /// + /// Target temperature for the buffer solution in Kelvin. + /// The reactor will heat or cool the buffer to reach this temperature. + /// + [DataField, AutoNetworkedField] + public float TargetTemperature = Atmospherics.T20C; + + /// + /// Maximum heat transfer rate when powered, in watts. + /// + [DataField] + public float HeatTransferPower = 500f; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingSmartDispenserComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSmartDispenserComponent.cs new file mode 100644 index 00000000000..a138e9dfbc5 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSmartDispenserComponent.cs @@ -0,0 +1,24 @@ +using Content.Shared.FixedPoint; +using Robust.Shared.GameStates; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing-connected smart dispenser that stores reagents pulled from the network +/// and fills labeled jugs on interaction. +/// +[RegisterComponent, NetworkedComponent] +public sealed partial class PlumbingSmartDispenserComponent : Component +{ + /// + /// The solution container name for the dispenser's reagent storage. + /// + [DataField] + public string SolutionName = "fridge"; + + /// + /// Maximum amount of any single reagent the fridge can store. + /// + [DataField] + public FixedPoint2 MaxPerReagent = FixedPoint2.New(200); +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingSynthesizerComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSynthesizerComponent.cs new file mode 100644 index 00000000000..60d9b3a0b66 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingSynthesizerComponent.cs @@ -0,0 +1,46 @@ +using Content.Shared.Chemistry.Reagent; +using Robust.Shared.GameStates; +using Robust.Shared.Prototypes; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing synthesizer that generates reagents from electrical power. +/// Drains power from its battery to produce a selected reagent into +/// its buffer. Other machines can pull the generated reagents via +/// the on this entity. +/// +[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)] +public sealed partial class PlumbingSynthesizerComponent : Component +{ + /// + /// Name of the outlet node for the plumbing network. + /// + [DataField] + public string OutletName = "outlet"; + + /// + /// Name of the buffer solution that holds generated reagents. + /// + [DataField] + public string BufferSolutionName = "buffer"; + + /// + /// Available reagents that can be generated. + /// Key is reagent prototype ID, value is power drain per unit. + /// + [DataField, AutoNetworkedField] + public Dictionary, float> GeneratableReagents = new(); + + /// + /// Currently selected reagent to generate. Null if none selected. + /// + [DataField, AutoNetworkedField] + public ProtoId? SelectedReagent; + + /// + /// Whether the synthesizer is currently enabled. + /// + [DataField, AutoNetworkedField] + public bool Enabled = true; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlumbingTankComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlumbingTankComponent.cs new file mode 100644 index 00000000000..3f0c63416a7 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlumbingTankComponent.cs @@ -0,0 +1,42 @@ +using Content.Shared.FixedPoint; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing tank that stores reagents from the network. +/// Actively pulls reagents from its inlet network each update tick. +/// Other machines can pull from this tank via . +/// +[RegisterComponent] +public sealed partial class PlumbingTankComponent : Component +{ + /// + /// The name of the solution on this entity that the tank uses. + /// + [DataField] + public string SolutionName = "tank"; + + /// + /// Name of the inlet node for receiving reagents. + /// + [DataField] + public string InletName = "inlet"; + + /// + /// Name of the outlet node for providing reagents. + /// + [DataField] + public string OutletName = "outlet"; + + /// + /// Amount to transfer per update when pushing to outputs. + /// + [DataField] + public FixedPoint2 TransferAmount = FixedPoint2.New(10); + + /// + /// Round-robin index for fair outlet selection. + /// Tracks which outlet to start from when pulling from multiple sources. + /// + public int RoundRobinIndex; +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/PlungeableComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/PlungeableComponent.cs new file mode 100644 index 00000000000..f1d2d9cf706 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/PlungeableComponent.cs @@ -0,0 +1,17 @@ +using Robust.Shared.Audio; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// Marker component for plumbing machines that can be plunged. +/// When a plunger is used on this entity, all solution containers are emptied onto the floor. +/// +[RegisterComponent] +public sealed partial class PlungeableComponent : Component +{ + /// + /// Sound played when the machine is successfully drained. + /// + [DataField] + public SoundSpecifier DrainSound = new SoundPathSpecifier("/Audio/Effects/Fluids/slosh.ogg"); +} diff --git a/Content.Shared/_Starlight/Plumbing/Components/StarlightPlumbingFilterComponent.cs b/Content.Shared/_Starlight/Plumbing/Components/StarlightPlumbingFilterComponent.cs new file mode 100644 index 00000000000..40b511242de --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/Components/StarlightPlumbingFilterComponent.cs @@ -0,0 +1,55 @@ +using Content.Shared.Chemistry.Reagent; +using Robust.Shared.GameStates; +using Robust.Shared.Prototypes; + +namespace Content.Shared._Starlight.Plumbing.Components; + +/// +/// A plumbing filter that separates reagents into two outputs. +/// Pulls reagents from the inlet into a buffer, then restricts which reagents +/// can be pulled from each outlet via . +/// Filter outlet only provides reagents in the filter list. +/// Passthrough outlet only provides reagents NOT in the filter list. +/// +[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)] +public sealed partial class StarlightPlumbingFilterComponent : Component // Hardlight: Goob also has a PlumbingFilterComponent which causes RT to throw up if both has the same name +{ + public const int MaxFilteredReagents = 4; + + /// + /// Name of the filter outlet node - only filtered reagents can be pulled here. + /// + [DataField] + public string FilterNodeName = "outletFilter"; + + /// + /// Name of the passthrough outlet node - only non-filtered reagents can be pulled here. + /// + [DataField] + public string PassthroughNodeName = "outletPassthrough"; + + /// + /// Name of the solution lane that holds filtered reagents. + /// + [DataField] + public string FilteredSolutionName = "bufferFiltered"; + + /// + /// Name of the solution lane that holds passthrough reagents. + /// + [DataField] + public string PassthroughSolutionName = "buffer"; + + /// + /// Whether the filter is currently enabled. + /// + [DataField, AutoNetworkedField] + public bool Enabled = true; + + /// + /// The reagent IDs to filter out to the filter port. + /// Multiple reagents can be filtered simultaneously. + /// + [DataField, AutoNetworkedField] + public HashSet> FilteredReagents = new(); +} diff --git a/Content.Shared/_Starlight/Plumbing/PlumbingVisuals.cs b/Content.Shared/_Starlight/Plumbing/PlumbingVisuals.cs new file mode 100644 index 00000000000..f75c6057037 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/PlumbingVisuals.cs @@ -0,0 +1,72 @@ +using Robust.Shared.Serialization; + +namespace Content.Shared._Starlight.Plumbing; + +[Serializable, NetSerializable] +public enum PlumbingVisuals : byte +{ + /// + /// Whether the plumbing machine is actively running. + /// + Running, + + /// + /// Directions that have PlumbingNodes defined. + /// Used to show jagged connectors in those directions. + /// + NodeDirections, + + /// + /// Directions that are connected. + /// Used to show smooth connector layer instead when connected. + /// + ConnectedDirections, + + /// + /// Packed connected layer index per cardinal direction. + /// Stores (layer + 1) in 4-bit nibbles, where 0 means no layer assigned. + /// + ConnectedLayerByDirection, + + /// + /// Directions that have inlet nodes. + /// Used to color inlet connectors red. + /// + InletDirections, + + /// + /// Directions that have outlet nodes. + /// Used to color outlet connectors blue. + /// + OutletDirections, + + /// + /// Whether the entity is covered by a floor tile. + /// Used to hide connector layers under floors without using SubFloorHide. + /// + CoveredByFloor, + + /// + /// Directions that have mixing inlet nodes. + /// Used to color mixing inlet connectors green. + /// + MixingInletDirections, + + /// + /// Whether this entity should use manifold connector rendering instead of regular per-direction connector layers. + /// + ManifoldMode, + + /// + /// Packed connected slot bitmask per cardinal direction for manifold-mode connectors. + /// Uses 4-bit nibbles per direction, where each bit is a slot index (0-3). + /// + ManifoldConnectedSlotsByDirection +} + +[Serializable, NetSerializable] +public enum PlumbingVisualLayers : byte +{ + Base, + Overlay +} diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingFilter.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingFilter.cs new file mode 100644 index 00000000000..7e161b833d3 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingFilter.cs @@ -0,0 +1,84 @@ +using Content.Shared.FixedPoint; +using Robust.Shared.Serialization; + +namespace Content.Shared._Starlight.Plumbing; + +/// +/// UI key for the plumbing filter interface. +/// +[Serializable, NetSerializable] +public enum PlumbingFilterUiKey : byte +{ + Key, +} + +/// +/// State sent to the client to update the filter UI. +/// +[Serializable, NetSerializable] +public sealed class PlumbingFilterBoundUserInterfaceState : BoundUserInterfaceState +{ + /// + /// The reagent IDs currently being filtered. + /// + public HashSet FilteredReagents { get; } + + /// + /// Whether the filter is enabled. + /// + public bool Enabled { get; } + + public PlumbingFilterBoundUserInterfaceState(HashSet filteredReagents, bool enabled) + { + FilteredReagents = filteredReagents; + Enabled = enabled; + } +} + +/// +/// Message to toggle the filter on/off. +/// +[Serializable, NetSerializable] +public sealed class PlumbingFilterToggleMessage : BoundUserInterfaceMessage +{ + public bool Enabled { get; } + + public PlumbingFilterToggleMessage(bool enabled) + { + Enabled = enabled; + } +} + +/// +/// Message to add a reagent to the filter list. +/// +[Serializable, NetSerializable] +public sealed class PlumbingFilterAddReagentMessage : BoundUserInterfaceMessage +{ + public string ReagentId { get; } + + public PlumbingFilterAddReagentMessage(string reagentId) + { + ReagentId = reagentId; + } +} + +/// +/// Message to remove a reagent from the filter list. +/// +[Serializable, NetSerializable] +public sealed class PlumbingFilterRemoveReagentMessage : BoundUserInterfaceMessage +{ + public string ReagentId { get; } + + public PlumbingFilterRemoveReagentMessage(string reagentId) + { + ReagentId = reagentId; + } +} + +/// +/// Message to clear all filtered reagents. +/// +[Serializable, NetSerializable] +public sealed class PlumbingFilterClearMessage : BoundUserInterfaceMessage; diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingPillPress.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingPillPress.cs new file mode 100644 index 00000000000..414ad6bd690 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingPillPress.cs @@ -0,0 +1,180 @@ +using Content.Shared.FixedPoint; +using Robust.Shared.Serialization; + +namespace Content.Shared._Starlight.Plumbing; + +/// +/// Whether the pill press produces pills or patches. +/// +[Serializable, NetSerializable] +public enum PillPressOutputMode : byte +{ + Pill, + // Patch, // HL: no patches +} + +/// +/// UI key for the plumbing pill press interface. +/// +[Serializable, NetSerializable] +public enum PlumbingPillPressUiKey : byte +{ + Key, +} + +/// +/// State sent to the client to update the pill press UI. +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressBoundUserInterfaceState : BoundUserInterfaceState +{ + public FixedPoint2 BufferVolume { get; } + public uint Dosage { get; } + public PillPressOutputMode OutputMode { get; } + public uint PillType { get; } + public string Label { get; } + public bool Enabled { get; } + + // Mixing mode fields + public bool MixingEnabled { get; } + public float InletRatioEast { get; } + public float InletRatioWest { get; } + public FixedPoint2 StagingEastVolume { get; } + public FixedPoint2 StagingWestVolume { get; } + + public PlumbingPillPressBoundUserInterfaceState( + FixedPoint2 bufferVolume, + uint dosage, + PillPressOutputMode outputMode, + uint pillType, + string label, + bool enabled, + bool mixingEnabled, + float inletRatioEast, + float inletRatioWest, + FixedPoint2 stagingEastVolume, + FixedPoint2 stagingWestVolume) + { + BufferVolume = bufferVolume; + Dosage = dosage; + OutputMode = outputMode; + PillType = pillType; + Label = label; + Enabled = enabled; + MixingEnabled = mixingEnabled; + InletRatioEast = inletRatioEast; + InletRatioWest = inletRatioWest; + StagingEastVolume = stagingEastVolume; + StagingWestVolume = stagingWestVolume; + } +} + +/// +/// Message to toggle the pill press on/off. +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressToggleMessage : BoundUserInterfaceMessage +{ + public bool Enabled { get; } + + public PlumbingPillPressToggleMessage(bool enabled) + { + Enabled = enabled; + } +} + +/// +/// Message to set the dosage (1–20). +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressSetDosageMessage : BoundUserInterfaceMessage +{ + public uint Dosage { get; } + + public PlumbingPillPressSetDosageMessage(uint dosage) + { + Dosage = dosage; + } +} + +/// +/// Message to switch between pill and patch output. +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressSetOutputModeMessage : BoundUserInterfaceMessage +{ + public PillPressOutputMode OutputMode { get; } + + public PlumbingPillPressSetOutputModeMessage(PillPressOutputMode outputMode) + { + OutputMode = outputMode; + } +} + +/// +/// Message to set the pill type visual (0–19). +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressSetPillTypeMessage : BoundUserInterfaceMessage +{ + public uint PillType { get; } + + public PlumbingPillPressSetPillTypeMessage(uint pillType) + { + PillType = pillType; + } +} + +/// +/// Message to set the output label for created pills/patches. +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressSetLabelMessage : BoundUserInterfaceMessage +{ + public string Label { get; } + + public PlumbingPillPressSetLabelMessage(string label) + { + Label = label; + } +} + +/// +/// Message to toggle mixing mode on/off. +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressSetMixingMessage : BoundUserInterfaceMessage +{ + public bool MixingEnabled { get; } + + public PlumbingPillPressSetMixingMessage(bool mixingEnabled) + { + MixingEnabled = mixingEnabled; + } +} + +/// +/// Identifies which mixing inlet is being configured. +/// +[Serializable, NetSerializable] +public enum PillPressInlet : byte +{ + East, + West, +} + +/// +/// Message to set the ratio for a mixing inlet. +/// +[Serializable, NetSerializable] +public sealed class PlumbingPillPressSetInletRatioMessage : BoundUserInterfaceMessage +{ + public PillPressInlet Inlet { get; } + public float Ratio { get; } + + public PlumbingPillPressSetInletRatioMessage(PillPressInlet inlet, float ratio) + { + Inlet = inlet; + Ratio = ratio; + } +} diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingReactor.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingReactor.cs new file mode 100644 index 00000000000..17abf48de30 --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingReactor.cs @@ -0,0 +1,131 @@ +using Content.Shared.FixedPoint; +using Robust.Shared.Serialization; + +namespace Content.Shared._Starlight.Plumbing; + +/// +/// UI key for the plumbing reactor interface. +/// +[Serializable, NetSerializable] +public enum PlumbingReactorUiKey : byte +{ + Key, +} + +/// +/// State sent to the client to update the reactor UI. +/// +[Serializable, NetSerializable] +public sealed class PlumbingReactorBoundUserInterfaceState : BoundUserInterfaceState +{ + /// + /// The reagent targets the reactor is trying to accumulate. + /// Key is reagent prototype ID, value is target quantity. + /// + public Dictionary ReagentTargets { get; } + + /// + /// Current quantities of reagents in the buffer. + /// + public Dictionary BufferContents { get; } + + /// + /// Current quantities of reagents in the output. + /// + public Dictionary OutputContents { get; } + + /// + /// Whether the reactor is enabled. + /// + public bool Enabled { get; } + + /// + /// Target temperature for the buffer in Kelvin. + /// + public float TargetTemperature { get; } + + /// + /// Current temperature of the buffer in Kelvin. + /// + public float CurrentTemperature { get; } + + public PlumbingReactorBoundUserInterfaceState( + Dictionary reagentTargets, + Dictionary bufferContents, + Dictionary outputContents, + bool enabled, + float targetTemperature, + float currentTemperature) + { + ReagentTargets = reagentTargets; + BufferContents = bufferContents; + OutputContents = outputContents; + Enabled = enabled; + TargetTemperature = targetTemperature; + CurrentTemperature = currentTemperature; + } +} + +/// +/// Message to toggle the reactor on/off. +/// +[Serializable, NetSerializable] +public sealed class PlumbingReactorToggleMessage : BoundUserInterfaceMessage +{ + public bool Enabled { get; } + + public PlumbingReactorToggleMessage(bool enabled) + { + Enabled = enabled; + } +} + +/// +/// Message to set a reagent target quantity. +/// +[Serializable, NetSerializable] +public sealed class PlumbingReactorSetTargetMessage : BoundUserInterfaceMessage +{ + public string ReagentId { get; } + public FixedPoint2 Quantity { get; } + + public PlumbingReactorSetTargetMessage(string reagentId, FixedPoint2 quantity) + { + ReagentId = reagentId; + Quantity = quantity; + } +} + +/// +/// Message to remove a reagent target. +/// +[Serializable, NetSerializable] +public sealed class PlumbingReactorRemoveTargetMessage : BoundUserInterfaceMessage +{ + public string ReagentId { get; } + + public PlumbingReactorRemoveTargetMessage(string reagentId) + { + ReagentId = reagentId; + } +} + +/// +/// Message to clear all reagent targets. +/// +[Serializable, NetSerializable] +public sealed class PlumbingReactorClearTargetsMessage : BoundUserInterfaceMessage; + +/// +/// Message to set the target temperature. +/// +[Serializable, NetSerializable] +public sealed class PlumbingReactorSetTemperatureMessage : BoundUserInterfaceMessage +{ + public float Temperature { get; } + + public PlumbingReactorSetTemperatureMessage(float temperature) + { + Temperature = temperature; + } +} diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingSmartDispenser.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSmartDispenser.cs new file mode 100644 index 00000000000..5b848fd6bcb --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSmartDispenser.cs @@ -0,0 +1,47 @@ +using System.Linq; +using Content.Shared.FixedPoint; +using Robust.Shared.Serialization; + +namespace Content.Shared._Starlight.Plumbing; + +[Serializable, NetSerializable] +public enum PlumbingSmartDispenserUiKey : byte +{ + Key, +} + +/// +/// A single reagent entry for the plumbing smart dispenser UI. +/// +[Serializable, NetSerializable] +public sealed class PlumbingSmartDispenserReagentEntry +{ + public string ReagentId; + public string LocalizedName; + public FixedPoint2 Quantity; + public Color Color; + + public PlumbingSmartDispenserReagentEntry(string reagentId, string localizedName, FixedPoint2 quantity, Color color) + { + ReagentId = reagentId; + LocalizedName = localizedName; + Quantity = quantity; + Color = color; + } +} + +/// +/// BUI state sent to the client containing the current reagent inventory. +/// +[Serializable, NetSerializable] +public sealed class PlumbingSmartDispenserBuiState : BoundUserInterfaceState +{ + public List Entries; + public float MaxPerReagent; + + public PlumbingSmartDispenserBuiState(List entries, float maxPerReagent) + { + Entries = entries; + MaxPerReagent = maxPerReagent; + } +} diff --git a/Content.Shared/_Starlight/Plumbing/SharedPlumbingSynthesizer.cs b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSynthesizer.cs new file mode 100644 index 00000000000..36a57c6064c --- /dev/null +++ b/Content.Shared/_Starlight/Plumbing/SharedPlumbingSynthesizer.cs @@ -0,0 +1,91 @@ +using Content.Shared.FixedPoint; +using Robust.Shared.Serialization; + +namespace Content.Shared._Starlight.Plumbing; + +/// +/// UI key for the plumbing synthesizer interface. +/// +[Serializable, NetSerializable] +public enum PlumbingSynthesizerUiKey : byte +{ + Key, +} + +/// +/// State sent to the client to update the synthesizer UI. +/// +[Serializable, NetSerializable] +public sealed class PlumbingSynthesizerBoundUserInterfaceState : BoundUserInterfaceState +{ + /// + /// Available reagents that can be generated. + /// Key is reagent prototype ID, value is power drain per unit. + /// + public Dictionary GeneratableReagents { get; } + + /// + /// Currently selected reagent ID, or null if none selected. + /// + public string? SelectedReagent { get; } + + /// + /// Current contents of the buffer. + /// + public Dictionary BufferContents { get; } + + /// + /// Whether the synthesizer is enabled. + /// + public bool Enabled { get; } + + /// + /// Current battery charge (0-1 ratio). + /// + public float BatteryCharge { get; } + + public PlumbingSynthesizerBoundUserInterfaceState( + Dictionary generatableReagents, + string? selectedReagent, + Dictionary bufferContents, + bool enabled, + float batteryCharge) + { + GeneratableReagents = generatableReagents; + SelectedReagent = selectedReagent; + BufferContents = bufferContents; + Enabled = enabled; + BatteryCharge = batteryCharge; + } +} + +/// +/// Message to toggle the synthesizer on/off. +/// +[Serializable, NetSerializable] +public sealed class PlumbingSynthesizerToggleMessage : BoundUserInterfaceMessage +{ + public bool Enabled { get; } + + public PlumbingSynthesizerToggleMessage(bool enabled) + { + Enabled = enabled; + } +} + +/// +/// Message to select which reagent to generate. +/// +[Serializable, NetSerializable] +public sealed class PlumbingSynthesizerSelectReagentMessage : BoundUserInterfaceMessage +{ + /// + /// The reagent ID to select, or null to deselect. + /// + public string? ReagentId { get; } + + public PlumbingSynthesizerSelectReagentMessage(string? reagentId) + { + ReagentId = reagentId; + } +} diff --git a/Resources/Locale/en-US/_Starlight/plumbing/pill-press.ftl b/Resources/Locale/en-US/_Starlight/plumbing/pill-press.ftl new file mode 100644 index 00000000000..882b5532bd8 --- /dev/null +++ b/Resources/Locale/en-US/_Starlight/plumbing/pill-press.ftl @@ -0,0 +1,15 @@ +# Pill Press UI +plumbing-pill-press-window-title = Plumbing Pill Press +plumbing-pill-press-status = Status: +plumbing-pill-press-enabled = Enabled +plumbing-pill-press-disabled = Disabled +plumbing-pill-press-output-mode = Output: +plumbing-pill-press-mode-pill = Pills +plumbing-pill-press-mode-patch = Patches +plumbing-pill-press-dosage = Dosage (u): +plumbing-pill-press-label = Label: +plumbing-pill-press-set = Set +plumbing-pill-press-pill-type = Pill Type +plumbing-pill-press-mixing-mode = Mixing Mode (E/W Inlets) +plumbing-pill-press-east-ratio = East: +plumbing-pill-press-west-ratio = West: diff --git a/Resources/Locale/en-US/_Starlight/plumbing/plumbing.ftl b/Resources/Locale/en-US/_Starlight/plumbing/plumbing.ftl new file mode 100644 index 00000000000..a8dcb1fef28 --- /dev/null +++ b/Resources/Locale/en-US/_Starlight/plumbing/plumbing.ftl @@ -0,0 +1,57 @@ +# Plumbing system localization + +plumbing-input-full = The input buffer is full! +plumbing-input-poured = Poured {$amount}u into the plumbing network. + +plumbing-output-empty = The output buffer is empty! +plumbing-output-filled = Filled container with {$amount}u from the plumbing network. + +# Reactor UI +plumbing-reactor-window-title = Plumbing Reactor +plumbing-reactor-status = Status: +plumbing-reactor-enabled = Enabled +plumbing-reactor-disabled = Disabled +plumbing-reactor-temperature = Target Temp: +plumbing-reactor-set = Set +plumbing-reactor-reset = Reset +plumbing-reactor-add-reagent = Add Reagent +plumbing-reactor-reagent-id = Reagent ID +plumbing-reactor-quantity = Quantity +plumbing-reactor-add = Add +plumbing-reactor-targets = Reaction Recipe +plumbing-reactor-clear = Clear All +plumbing-reactor-remove-selected = Remove Selected +plumbing-reactor-output = Output Contents +plumbing-reactor-invalid-reagent = Unknown reagent: {$reagent} + +# Filter UI +starlight-plumbing-filter-window-title = Plumbing Filter +plumbing-filter-status = Status: +plumbing-filter-enabled = Enabled +plumbing-filter-disabled = Disabled +plumbing-filter-add-reagent = Add Reagent to Filter +plumbing-filter-reagent-id = Reagent ID +plumbing-filter-add = Add +plumbing-filter-filtered = Filtered Reagents +plumbing-filter-clear = Clear All +plumbing-filter-remove-selected = Remove Selected +plumbing-filter-invalid-reagent = Unknown reagent: {$reagent} +plumbing-filter-max-reagents = You can only filter up to {$count} reagents. + +# Synthesizer UI +plumbing-synthesizer-window-title = Plumbing Synthesizer +plumbing-synthesizer-status = Status: +plumbing-synthesizer-enabled = Enabled +plumbing-synthesizer-disabled = Disabled +plumbing-synthesizer-battery = Battery: +plumbing-synthesizer-power = Power: +plumbing-synthesizer-power-on = Connected +plumbing-synthesizer-power-off = No Power +plumbing-synthesizer-select-reagent = Select Reagent +plumbing-synthesizer-none = None +plumbing-synthesizer-buffer = Buffer Contents +plumbing-synthesizer-buffer-empty = Empty + +# Plunger drain +plumbing-drain-success = Drained {$amount}u onto the floor. +plumbing-drain-empty = Nothing to drain. diff --git a/Resources/Locale/en-US/_Starlight/plumbing/smart-dispenser.ftl b/Resources/Locale/en-US/_Starlight/plumbing/smart-dispenser.ftl new file mode 100644 index 00000000000..d00b6d6f14f --- /dev/null +++ b/Resources/Locale/en-US/_Starlight/plumbing/smart-dispenser.ftl @@ -0,0 +1,10 @@ +plumbing-smart-dispenser-window-title = Smart Dispenser +plumbing-smart-dispenser-header = Chemical Storage +plumbing-smart-dispenser-reagent-entry = {$reagent}: {$amount}u +plumbing-smart-dispenser-empty = No reagents stored. +plumbing-smart-dispenser-total = {$count} reagent(s) — {$total}u total +plumbing-smart-dispenser-no-label = Container has no label. +plumbing-smart-dispenser-no-match = Could not match label to any known reagent. +plumbing-smart-dispenser-not-in-stock = {$reagent} is not in stock. +plumbing-smart-dispenser-jug-full = Container is already full. +plumbing-smart-dispenser-filled = Filled {$amount}u of {$reagent}. diff --git a/Resources/Locale/en-US/_Starlight/rpld/rpld-components.ftl b/Resources/Locale/en-US/_Starlight/rpld/rpld-components.ftl new file mode 100644 index 00000000000..5e6cc15aec1 --- /dev/null +++ b/Resources/Locale/en-US/_Starlight/rpld/rpld-components.ftl @@ -0,0 +1,3 @@ +rpld-component-ducts = Plumbing Ducts +rpld-component-supply = Plumbing Supply +rpld-component-production = Plumbing Production diff --git a/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl b/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl index c000811e77d..5a7afa7d68a 100644 --- a/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl +++ b/Resources/Locale/en-US/chemistry/components/chem-master-component.ftl @@ -12,6 +12,8 @@ chem-master-window-input-tab = Input chem-master-window-output-tab = Output chem-master-window-container-label = Container chem-master-window-eject-button = Eject +chem-master-window-valve-open = Valve: Open +chem-master-window-valve-closed = Valve: Closed chem-master-window-no-container-loaded-text = No container loaded. chem-master-window-buffer-text = Buffer chem-master-window-buffer-label = buffer: diff --git a/Resources/Locale/en-US/chemistry/components/reagent-dispenser-component.ftl b/Resources/Locale/en-US/chemistry/components/reagent-dispenser-component.ftl index 37697c45176..6d8fae66613 100644 --- a/Resources/Locale/en-US/chemistry/components/reagent-dispenser-component.ftl +++ b/Resources/Locale/en-US/chemistry/components/reagent-dispenser-component.ftl @@ -17,3 +17,5 @@ reagent-dispenser-window-no-container-loaded-text = No container loaded. reagent-dispenser-window-reagent-name-not-found-text = Reagent name not found reagent-dispenser-window-unknown-reagent-text = Unknown reagent reagent-dispenser-window-quantity-label-text = {$quantity}u +reagent-dispenser-window-valve-open = Close Valve +reagent-dispenser-window-valve-closed = Open Valve diff --git a/Resources/Prototypes/Entities/Structures/Dispensers/base_structuredispensers.yml b/Resources/Prototypes/Entities/Structures/Dispensers/base_structuredispensers.yml index 31e233625a3..d0bb63cdd9e 100644 --- a/Resources/Prototypes/Entities/Structures/Dispensers/base_structuredispensers.yml +++ b/Resources/Prototypes/Entities/Structures/Dispensers/base_structuredispensers.yml @@ -10,6 +10,12 @@ noRot: true - type: Clickable - type: InteractionOutline + - type: Appearance + # Starlight-start: Plumbing connector visuals + - type: PlumbingConnectorAppearance + offset: 0.09375 + - type: AtmosPipeColor + # Starlight-end - type: Physics bodyType: Static - type: Fixtures @@ -73,3 +79,33 @@ - type: StaticPrice price: 1000 - type: WiresPanel + # Starlight-start: Plumbing outlet + - type: NodeContainer + nodes: + outletNorth: # Provides reagents TO the network (all directions) + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + outletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + outletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + outletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: PlumbingOutlet + solutionName: beaker + connectedOutlets: true + outletNames: + - outletNorth + - outletEast + - outletSouth + - outletWest + containerSlotId: beakerSlot + enabled: false + # Starlight-end diff --git a/Resources/Prototypes/Entities/Structures/Machines/chem_master.yml b/Resources/Prototypes/Entities/Structures/Machines/chem_master.yml index a6096b7a480..45b3a5c6825 100644 --- a/Resources/Prototypes/Entities/Structures/Machines/chem_master.yml +++ b/Resources/Prototypes/Entities/Structures/Machines/chem_master.yml @@ -14,6 +14,11 @@ - state: mixer_screens shader: unshaded map: ["enum.PowerDeviceVisualLayers.Powered"] + # Starlight-start: Plumbing connector visuals + - type: PlumbingConnectorAppearance + offset: 0.09375 + - type: AtmosPipeColor + # Starlight-end - type: Icon sprite: Structures/Machines/mixer.rsi state: mixer_empty @@ -114,8 +119,42 @@ maxVol: 1000000 - type: DumpableSolution solution: buffer - unlimited: true + unlimited: true # Starlight plumbing normally turns this off but maybe not for us lmao - type: GuideHelp guides: - Chemicals - Chemist + # Starlight - Plumbing integration + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingInlet + solutionName: buffer + inletNames: + - inletNorth + - inletEast + - inletWest + transferAmount: 40 + - type: PlumbingOutlet + solutionName: beaker + connectedOutlets: true + containerSlotId: beakerSlot + enabled: false + - type: NodeContainer + nodes: + inletNorth: # Pulls reagents FROM the network (north, east, west sides) + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + inletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + inletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + outlet: # Provides reagents TO the network (south side) + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + # Starlight-end diff --git a/Resources/Prototypes/Entities/Structures/Machines/reagent_grinder.yml b/Resources/Prototypes/Entities/Structures/Machines/reagent_grinder.yml index 73ef70f7516..a23c5c1f626 100644 --- a/Resources/Prototypes/Entities/Structures/Machines/reagent_grinder.yml +++ b/Resources/Prototypes/Entities/Structures/Machines/reagent_grinder.yml @@ -78,6 +78,12 @@ name: industrial reagent grinder description: An industrial reagent grinder. components: + - type: Appearance + # Starlight-start: Plumbing connector visuals + - type: PlumbingConnectorAppearance + offset: 0.09375 + - type: AtmosPipeColor + # Starlight-end - type: SolutionContainerManager solutions: output: @@ -125,3 +131,30 @@ solution: output - type: ExaminableSolution solution: output + # Starlight - Plumbing integration + - type: PlumbingOutlet + solutionName: output + connectedOutlets: true + outletNames: + - outletNorth + - outletEast + - outletSouth + - outletWest + - type: NodeContainer + nodes: + outletNorth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + outletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + outletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + outletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West diff --git a/Resources/Prototypes/Guidebook/engineering.yml b/Resources/Prototypes/Guidebook/engineering.yml index a61e6c4a728..cce81640394 100644 --- a/Resources/Prototypes/Guidebook/engineering.yml +++ b/Resources/Prototypes/Guidebook/engineering.yml @@ -6,6 +6,7 @@ - Construction - Power - Atmospherics + - StarlightPlumbing # Starlight - ShuttleCraft - Networking - Automation diff --git a/Resources/Prototypes/_StarLight/Catalog/Cargo/cargo_engineering.yml b/Resources/Prototypes/_StarLight/Catalog/Cargo/cargo_engineering.yml new file mode 100644 index 00000000000..7979d9ea6aa --- /dev/null +++ b/Resources/Prototypes/_StarLight/Catalog/Cargo/cargo_engineering.yml @@ -0,0 +1,9 @@ +- type: cargoProduct + id: EngineeringRPLD + icon: + sprite: _Starlight/Objects/Tools/rpld.rsi + state: icon + product: CrateRPLD + cost: 800 + category: cargoproduct-category-name-engineering + group: market diff --git a/Resources/Prototypes/_StarLight/Catalog/Fills/Crates/engineering.yml b/Resources/Prototypes/_StarLight/Catalog/Fills/Crates/engineering.yml new file mode 100644 index 00000000000..da3cf8fffde --- /dev/null +++ b/Resources/Prototypes/_StarLight/Catalog/Fills/Crates/engineering.yml @@ -0,0 +1,10 @@ +- type: entity + parent: CrateEngineeringSecure + id: CrateRPLD + name: RPLD crate + description: A crate containing a single rapid plumbing device. + components: + - type: EntityTableContainerFill + containers: + entity_storage: + id: RPLD diff --git a/Resources/Prototypes/_StarLight/Entities/Guidebook/plumbing_ducts.yml b/Resources/Prototypes/_StarLight/Entities/Guidebook/plumbing_ducts.yml new file mode 100644 index 00000000000..e24f724713e --- /dev/null +++ b/Resources/Prototypes/_StarLight/Entities/Guidebook/plumbing_ducts.yml @@ -0,0 +1,67 @@ +# ============================================================================ +# Guidebook Duct Entities +# ============================================================================ +# Duct variants specifically for GuideEntityEmbed display. +# Real ducts have SubFloorHide + visible: false, which prevents proper +# rendering in guidebook embeds +# ============================================================================ + +- type: entity + id: GuidebookPlumbingDuctStraight + categories: [ HideSpawnMenu ] + name: fluid duct + suffix: Straight, Guidebook + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + drawdepth: ThinPipe + layers: + - state: storageStraight + +- type: entity + id: GuidebookPlumbingDuctBend + categories: [ HideSpawnMenu ] + name: fluid duct + suffix: Bend, Guidebook + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + drawdepth: ThinPipe + layers: + - state: storageBend + +- type: entity + id: GuidebookPlumbingDuctTJunction + categories: [ HideSpawnMenu ] + name: fluid duct + suffix: T-Junction, Guidebook + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + drawdepth: ThinPipe + layers: + - state: storageTjunction + +- type: entity + id: GuidebookPlumbingDuctFourway + categories: [ HideSpawnMenu ] + name: fluid duct + suffix: Fourway, Guidebook + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + drawdepth: ThinPipe + layers: + - state: storageFourway + +- type: entity + id: GuidebookPlumbingDuctManifold + categories: [ HideSpawnMenu ] + name: fluid manifold + suffix: Guidebook + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi + drawdepth: ThinPipe + layers: + - state: duct_manifold diff --git a/Resources/Prototypes/_StarLight/Entities/Objects/Tools/tools.yml b/Resources/Prototypes/_StarLight/Entities/Objects/Tools/tools.yml index f80dc19112e..3e2be4407db 100644 --- a/Resources/Prototypes/_StarLight/Entities/Objects/Tools/tools.yml +++ b/Resources/Prototypes/_StarLight/Entities/Objects/Tools/tools.yml @@ -880,4 +880,69 @@ - Wrench - PlantSampleTaker - Wirecutter - - Screwdriver \ No newline at end of file + - Screwdriver + +# ============================================================================= +# RPLD (Rapid Plumbing Device) - places plumbing ducts and machines +# ============================================================================= +- type: entity + id: RPLD + parent: RCD + name: RPLD + description: A device used to rapidly deploy plumbing ducts and machines. + components: + - type: RCD + isRPLD: true + availablePrototypes: + - PlumbingRpldDuctStraight + - PlumbingRpldDuctBend + - PlumbingRpldDuctTJunction + - PlumbingRpldDuctFourway + - PlumbingRpldDuctManifold + - PlumbingRpldTank + - PlumbingRpldBuffer + - PlumbingRpldInput + - PlumbingRpldOutput + - PlumbingRpldSink + - PlumbingRpldReactor + - PlumbingRpldPillPress + - PlumbingRpldFilter + - PlumbingRpldSynthesizer + - PlumbingRpldSmartDispenser + - PlumbingRpldDrain + - PlumbingRpldDisposal + - Deconstruct + - type: LimitedCharges + maxCharges: 45 + - type: Sprite + sprite: _Starlight/Objects/Tools/rpld.rsi + +- type: entity + id: RPLDEmpty + parent: RPLD + suffix: Empty + components: + - type: LimitedCharges + lastCharges: -1 + +- type: entity + id: RPLDRecharging + parent: RPLD + name: experimental RPLD + description: Cyborg-mounted Rapid Plumbing Device which creates compressed matter on the fly using an internal fabricator. + suffix: AutoRecharge + components: + - type: LimitedCharges + maxCharges: 20 + - type: AutoRecharge + rechargeDuration: 10 + +- type: entity + id: RPLDExperimental + parent: RPLD + suffix: Admeme + name: experimental RPLD + description: A bluespace-enhanced rapid plumbing device that passively generates its own compressed matter. + components: + - type: AutoRecharge + rechargeDuration: 1 diff --git a/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/ducts.yml b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/ducts.yml new file mode 100644 index 00000000000..22872f4296e --- /dev/null +++ b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/ducts.yml @@ -0,0 +1,425 @@ +# ============================================================================ +# Plumbing Ducts +# ============================================================================ +# Ducts allow transport of reagents through the plumbing network. +# All ducts inherit from PlumbingDuctBase for common components. +# ============================================================================ + +# ============================================================================ +# BASE ENTITY +# ============================================================================ + +- type: entity + abstract: true + parent: BaseItem + id: PlumbingDuctBase + name: fluid duct + description: A duct for transporting reagents through the plumbing network. + placement: + mode: SnapgridCenter + components: + - type: AtmosPipeLayers + numberOfPipeLayers: 3 + spriteLayersRsiPaths: + enum.PipeVisualLayers.Pipe: + Primary: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + Secondary: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + Tertiary: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + - type: Visibility + layer: 1 + - type: Item + size: Normal + - type: Transform + anchored: true + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + drawdepth: ThinPipe + visible: false + - type: Appearance + - type: PipeColorVisuals + - type: AtmosPipeColor + - type: Clickable + - type: InteractionOutline + - type: SubFloorHide + - type: CollideOnAnchor + - type: Anchorable + - type: Pullable + - type: Rotatable + - type: NodeContainer + - type: Tag + tags: + - PlumbingDuct + - type: Physics + canCollide: false + bodyType: static + - type: Damageable + damageContainer: StructuralInorganic + damageModifierSet: Metallic + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 200 + behaviors: + - !type:DoActsBehavior + acts: ["Destruction"] + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:PlaySoundBehavior + sound: + collection: MetalBreak + params: + volume: -8 + - !type:DoActsBehavior + acts: [Breakage] + - type: PipeRestrictOverlap + - type: RCDDeconstructable + cost: 1 + delay: 2 + fx: EffectRCDDeconstruct2 + rpld: true + - type: StaticPrice + price: 20 + +# ============================================================================ +# DUCT VARIANTS +# ============================================================================ + +# -------------------------------- +# Straight Duct +# -------------------------------- +- type: entity + parent: PlumbingDuctBase + id: PlumbingDuctStraight + name: fluid duct + suffix: Straight + placement: + mode: AlignAtmosPipeLayers + components: + - type: NodeContainer + nodes: + duct: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: Longitudinal + - type: Sprite + layers: + - state: ductStraight + map: [ "enum.PipeVisualLayers.Pipe" ] + - type: PipeAppearance + sprite: + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + state: ductConnector + - type: AtmosPipeLayers + alternativePrototypes: + Primary: PlumbingDuctStraight + Secondary: PlumbingDuctStraightAlt1 + Tertiary: PlumbingDuctStraightAlt2 + - type: Item + storedSprite: + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: storageStraight + shape: + - 0,0,0,2 + +# -------------------------------- +# Bend Duct +# -------------------------------- +- type: entity + parent: PlumbingDuctBase + id: PlumbingDuctBend + name: fluid duct + suffix: Bend + placement: + mode: AlignAtmosPipeLayers + components: + - type: NodeContainer + nodes: + duct: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: SWBend + - type: Sprite + layers: + - state: ductBend + map: [ "enum.PipeVisualLayers.Pipe" ] + - type: PipeAppearance + sprite: + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + state: ductConnector + - type: AtmosPipeLayers + alternativePrototypes: + Primary: PlumbingDuctBend + Secondary: PlumbingDuctBendAlt1 + Tertiary: PlumbingDuctBendAlt2 + - type: Item + size: Small + storedSprite: + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: storageBend + +# -------------------------------- +# T-Junction Duct +# -------------------------------- +- type: entity + parent: PlumbingDuctBase + id: PlumbingDuctTJunction + name: fluid duct + suffix: T-Junction + placement: + mode: AlignAtmosPipeLayers + components: + - type: NodeContainer + nodes: + duct: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: TSouth + - type: Sprite + layers: + - state: ductTJunction + map: [ "enum.PipeVisualLayers.Pipe" ] + - type: PipeAppearance + sprite: + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + state: ductConnector + - type: AtmosPipeLayers + alternativePrototypes: + Primary: PlumbingDuctTJunction + Secondary: PlumbingDuctTJunctionAlt1 + Tertiary: PlumbingDuctTJunctionAlt2 + - type: Item + storedSprite: + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: storageTjunction + +# -------------------------------- +# Fourway Duct +# -------------------------------- +- type: entity + parent: PlumbingDuctBase + id: PlumbingDuctFourway + name: fluid duct + suffix: Fourway + placement: + mode: AlignAtmosPipeLayers + components: + - type: NodeContainer + nodes: + duct: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: Fourway + - type: Sprite + layers: + - state: ductFourway + map: [ "enum.PipeVisualLayers.Pipe" ] + - type: PipeAppearance + sprite: + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + state: ductConnector + - sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + state: ductConnector + - type: AtmosPipeLayers + alternativePrototypes: + Primary: PlumbingDuctFourway + Secondary: PlumbingDuctFourwayAlt1 + Tertiary: PlumbingDuctFourwayAlt2 + - type: Item + size: Small + storedSprite: + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: storageFourway + +# -------------------------------- +# Plumbing Manifold Duct +# -------------------------------- +- type: entity + parent: PlumbingDuctBase + id: PlumbingDuctManifold + name: fluid manifold + description: A manifold for connecting ducts on all layers. + placement: + mode: AlignAtmosPipeLayers + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi + layers: + - state: duct_manifold + map: [ "enum.PipeVisualLayers.Pipe" ] + - type: PlumbingConnectorAppearance + offset: 0.09375 + - type: PlumbingManifold + sideA: [sideA0, sideA1, sideA2] + sideB: [sideB0, sideB1, sideB2] + - type: NodeContainer + nodes: + sideA0: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + pipeLayer: 0 + sideA1: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + pipeLayer: 1 + sideA2: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + pipeLayer: 2 + sideB0: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + pipeLayer: 0 + sideB1: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + pipeLayer: 1 + sideB2: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + pipeLayer: 2 + - type: AtmosPipeLayers + pipeLayersLocked: true + spriteLayersRsiPaths: + enum.PipeVisualLayers.Pipe: + Primary: _Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi + Secondary: _Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi + Tertiary: _Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi + alternativePrototypes: + Primary: PlumbingDuctManifold + Secondary: PlumbingDuctManifoldAlt1 + Tertiary: PlumbingDuctManifoldAlt2 + - type: Item + storedSprite: + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi + state: storageStraight + +# ============================================================================ +# ALTERNATIVE LAYER PROTOTYPES +# ============================================================================ + +- type: entity + abstract: true + id: PlumbingDuctLayerAlt1 + components: + - type: AtmosPipeLayers + pipeLayer: Secondary + +- type: entity + abstract: true + id: PlumbingDuctLayerAlt2 + components: + - type: AtmosPipeLayers + pipeLayer: Tertiary + +- type: entity + parent: [PlumbingDuctLayerAlt1, PlumbingDuctStraight] + id: PlumbingDuctStraightAlt1 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt1 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt2, PlumbingDuctStraight] + id: PlumbingDuctStraightAlt2 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt2 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt1, PlumbingDuctBend] + id: PlumbingDuctBendAlt1 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt1 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt2, PlumbingDuctBend] + id: PlumbingDuctBendAlt2 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt2 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt1, PlumbingDuctTJunction] + id: PlumbingDuctTJunctionAlt1 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt1 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt2, PlumbingDuctTJunction] + id: PlumbingDuctTJunctionAlt2 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt2 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt1, PlumbingDuctFourway] + id: PlumbingDuctFourwayAlt1 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt1 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt2, PlumbingDuctFourway] + id: PlumbingDuctFourwayAlt2 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt2 + sprite: _Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt1, PlumbingDuctManifold] + id: PlumbingDuctManifoldAlt1 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt1 + sprite: _Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi + +- type: entity + parent: [PlumbingDuctLayerAlt2, PlumbingDuctManifold] + id: PlumbingDuctManifoldAlt2 + categories: [ HideSpawnMenu ] + components: + - type: Sprite + drawdepth: ThinPipeAlt2 + sprite: _Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi diff --git a/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/plumbing_machines.yml b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/plumbing_machines.yml new file mode 100644 index 00000000000..2244cd2c3be --- /dev/null +++ b/Resources/Prototypes/_StarLight/Entities/Structures/Piping/Plumbing/plumbing_machines.yml @@ -0,0 +1,927 @@ +# Base plumbing machine entity - all plumbing machines inherit from this +- type: entity + abstract: true + id: PlumbingMachineBase + placement: + mode: SnapgridCenter + components: + - type: Transform + anchored: true + noRot: false + - type: Sprite + noRot: false # Allow rotation so connectors face correct direction + - type: Clickable + - type: Appearance + - type: PlumbingConnectorAppearance + offset: 0.09375 + - type: InteractionOutline + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhileAnchored: true + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: -0.25,-0.25,0.25,0.25 + density: 190 + mask: + - MachineMask + layer: + - MachineLayer + - type: AtmosPipeColor + - type: RCDDeconstructable + cost: 2 + delay: 2 + fx: EffectRCDDeconstruct2 + rpld: true + - type: Damageable + damageContainer: StructuralInorganic + damageModifierSet: Metallic + +# ============================================================================= +# Plumbing Tank - stores reagents in the network +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingTank + name: plumbing tank + description: Stores up to 2000u of reagents. Use tanks to buffer reagents between production stages or just store large amounts of reagents. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: tank + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingInlet + solutionName: tank + - type: Plungeable + - type: PlumbingOutlet + solutionName: tank + connectedOutlets: true + outletNames: + - outletSouth + - outletEast + - outletWest + - type: SolutionContainerManager + solutions: + tank: + maxVol: 2000 + canReact: false + - type: ExaminableSolution + solution: tank + - type: NodeContainer + nodes: + inlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + outletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + outletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + outletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: tank + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 100 + +# ============================================================================= +# Plumbing Buffer - small low-profile tank for reagent buffering +# ============================================================================= +- type: entity + parent: PlumbingTank + id: PlumbingBuffer + name: plumbing buffer + description: Stores up to 200u of reagents. Useful for supplying separate duct networks with its unconnected outlets. + components: + - type: Physics + bodyType: Static + canCollide: false + - type: Fixtures + fixtures: {} + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: buffer_tank + - type: PlumbingOutlet + solutionName: tank + connectedOutlets: false + outletNames: + - outletSouth + - outletEast + - outletWest + - type: SolutionContainerManager + solutions: + tank: + maxVol: 200 + canReact: false + +# ============================================================================= +# Plumbing Input - pour reagents into the network +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingInput + name: plumbing input + description: A small tank you pour reagents into. Other machines pull from this. Connects in all directions. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: pipe_input + - type: PlumbingInput + solutionName: input + - type: Plungeable + - type: PlumbingOutlet + solutionName: input + connectedOutlets: true + outletNames: + - outletNorth + - outletEast + - outletSouth + - outletWest + - type: SolutionContainerManager + solutions: + input: + maxVol: 100 + canReact: false + - type: ExaminableSolution + solution: input + - type: NodeContainer + nodes: + outletNorth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + outletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + outletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + outletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: input + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 75 + +# ============================================================================= +# Plumbing Sink - draws reagents from the network, has an outlet for solutions dumped into it +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingSink + name: plumbing sink + description: A sink connected to the plumbing network. Draw reagents from it with a container, or dump reagents into it to send them down the drain. Connects in all directions. + components: + - type: Sprite + sprite: Structures/Furniture/sink.rsi + drawdepth: FloorObjects + layers: + - state: sink_wide + - type: Rotatable + rotateWhileAnchored: false + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingInlet + solutionName: output + inletNames: + - inletNorth + - inletEast + - inletWest + - type: PlumbingOutput + solutionName: output + - type: PlumbingOutlet + solutionName: drain + connectedOutlets: true + - type: DumpableSolution + solution: drain + - type: Plungeable + - type: SolutionContainerManager + solutions: + output: + maxVol: 100 + canReact: false + drain: + maxVol: 100 + canReact: false + - type: ExaminableSolution + solution: output + - type: NodeContainer + nodes: + inletNorth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + inletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + inletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + outlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: output + - !type:SpillBehavior + solution: drain + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 100 + +# ============================================================================= +# Plumbing Output - draw reagents from the network +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingOutput + name: plumbing output + description: A small tank that pulls reagents from the network. Draw from it with a container. Connects in all directions. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: pipe_output + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingInlet + solutionName: output + inletNames: + - inletNorth + - inletEast + - inletSouth + - inletWest + - type: PlumbingOutput + solutionName: output + - type: Plungeable + - type: SolutionContainerManager + solutions: + output: + maxVol: 100 + canReact: false + - type: ExaminableSolution + solution: output + - type: NodeContainer + nodes: + inletNorth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + inletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + inletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + inletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: output + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 75 + +# ============================================================================= +# Plumbing Reactor - accumulates reagents and triggers reactions +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingReactor + name: plumbing reactor + description: Pulls target reagents in up to configured quantities from its inlet and triggers reactions. Requires power. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: reaction_chamber + map: [ "enum.PlumbingVisualLayers.Base" ] + - type: GenericVisualizer + visuals: + enum.PlumbingVisuals.Running: + enum.PlumbingVisualLayers.Base: + True: { state: reaction_chamber_on } + False: { state: reaction_chamber } + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingReactor + bufferSolutionName: buffer + outputSolutionName: output + inletName: inlet + - type: PlumbingInlet + solutionName: buffer + inletNames: + - inlet + transferAmount: 0 + - type: Plungeable + - type: PlumbingOutlet + solutionName: output + connectedOutlets: true + - type: SolutionContainerManager + solutions: + buffer: + maxVol: 100 + canReact: false # Reactions triggered manually when targets met + output: + maxVol: 100 + canReact: false + - type: ExaminableSolution + solution: output + - type: NodeContainer + nodes: + inlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + outlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + - type: UserInterface + interfaces: + enum.PlumbingReactorUiKey.Key: + type: PlumbingReactorBoundUserInterface + - type: ActivatableUI + key: enum.PlumbingReactorUiKey.Key + - type: ApcPowerReceiver + powerLoad: 750 + - type: ExtensionCableReceiver + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: buffer + - !type:SpillBehavior + solution: output + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 150 + +# ============================================================================= +# Plumbing Smart Dispenser - stores reagents from the network, fills labeled jugs +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingSmartDispenser + name: plumbing smart dispenser + description: Pulls in all reagents from its inlets and stores up to 200u of each type. Use a labeled jug on the dispenser to fill it with the matching reagent. Requires power. + components: + - type: Sprite + sprite: Structures/Machines/smartfridge.rsi + layers: + - state: smartfridge + map: ["enum.StorageVisualLayers.Base"] + - state: smartfridge_door + map: ["enum.StorageVisualLayers.Door"] + shader: unshaded + - type: PointLight + radius: 1.2 + energy: 3.0 + color: "#9dc5c9" + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingInlet + solutionName: fridge + inletNames: + - inletNorth + - inletEast + - inletSouth + - inletWest + transferAmount: 40 + - type: PlumbingSmartDispenser + solutionName: fridge + maxPerReagent: 200 + - type: SolutionContainerManager + solutions: + fridge: + maxVol: 50000 + canReact: false + - type: ExaminableSolution + solution: fridge + - type: NodeContainer + nodes: + inletNorth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + inletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + inletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + inletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: UserInterface + interfaces: + enum.PlumbingSmartDispenserUiKey.Key: + type: PlumbingSmartDispenserBoundUserInterface + - type: ActivatableUI + key: enum.PlumbingSmartDispenserUiKey.Key + - type: ApcPowerReceiver + powerLoad: 200 + - type: ExtensionCableReceiver + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 200 + behaviors: + - !type:SpillBehavior + solution: fridge + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 200 + +# ============================================================================= +# Plumbing Pill Press - automatically creates pills or patches from reagents +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingPillPress + name: plumbing pill press + description: Pulls in reagents and presses them into pills or patches at a configurable dosage. Has optional mixing inlets for ratio-controlled mixing. Requires power. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: pill_press_off + map: [ "enum.PlumbingVisualLayers.Base" ] + - type: GenericVisualizer + visuals: + enum.PlumbingVisuals.Running: + enum.PlumbingVisualLayers.Base: + True: { state: pill_press } + False: { state: pill_press_off } + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingPillPress + bufferSolutionName: buffer + dosage: 10 + - type: PlumbingConnectorAppearance + offset: 0.09375 + - type: PlumbingInlet + solutionName: buffer + inletNames: + - inlet + - type: SolutionContainerManager + solutions: + buffer: + maxVol: 20 + canReact: false + stagingEast: + maxVol: 20 + canReact: false + stagingWest: + maxVol: 20 + canReact: false + - type: ExaminableSolution + solution: buffer + - type: NodeContainer + nodes: + inlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + mixingInletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + mixingInletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: UserInterface + interfaces: + enum.PlumbingPillPressUiKey.Key: + type: PlumbingPillPressBoundUserInterface + - type: ActivatableUI + key: enum.PlumbingPillPressUiKey.Key + - type: ApcPowerReceiver + powerLoad: 200 + - type: ExtensionCableReceiver + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: buffer + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 150 +# ============================================================================= +# Plumbing Filter - separates specific reagents into two outputs +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingFilter + name: Plumbing Filter + description: Filters specific reagents from a duct network. Filtered reagents are sent to the side outlet while other reagents passthrough. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: filter + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingInlet + solutionName: buffer + - type: StarlightPlumbingFilter + filterNodeName: outletFilter + passthroughNodeName: outletPassthrough + filteredSolutionName: bufferFiltered + passthroughSolutionName: buffer + - type: Plungeable + - type: PlumbingOutlet + solutionName: buffer + outletNames: + - outletFilter + - outletPassthrough + - type: SolutionContainerManager + solutions: + buffer: + maxVol: 40 + canReact: false + bufferFiltered: + maxVol: 40 + canReact: false + - type: ExaminableSolution + solution: buffer + - type: NodeContainer + nodes: + inlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + outletFilter: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + outletPassthrough: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + - type: AtmosPipeColor + color: "#8B4513" + - type: UserInterface + interfaces: + enum.PlumbingFilterUiKey.Key: + type: PlumbingFilterBoundUserInterface + - type: ActivatableUI + key: enum.PlumbingFilterUiKey.Key + - type: Flippable + mirrorEntity: PlumbingFilterFlipped + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: buffer + - !type:SpillBehavior + solution: bufferFiltered + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 125 + +- type: entity + parent: PlumbingFilter + id: PlumbingFilterFlipped + suffix: Flipped + description: Filters specific reagents from a duct network. Filtered reagents are sent to the side outlet while other reagents passthrough. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: filterF + - type: NodeContainer + nodes: + inlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + outletFilter: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + outletPassthrough: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + - type: Flippable + mirrorEntity: PlumbingFilter + +# ============================================================================= +# Plumbing Synthesizer - generates reagents from power +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingSynthesizer + name: plumbing synthesizer + description: Generates basic reagents using power from an internal battery. + components: + - type: Sprite + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + noRot: false + layers: + - state: synthesizer + - state: synthesizer_overlay + map: [ "enum.PlumbingVisualLayers.Overlay" ] + visible: false + - type: GenericVisualizer + visuals: + enum.PlumbingVisuals.Running: + enum.PlumbingVisualLayers.Overlay: + True: { visible: true } + False: { visible: false } + - type: PlumbingDevice + updateInterval: 2 + - type: PlumbingSynthesizer + bufferSolutionName: buffer + generatableReagents: + Iron: 2 + Carbon: 2 + Copper: 2 + Hydrogen: 2 + Oxygen: 0 + Sugar: 2 + Silicon: 5 + Phosphorus: 5 + - type: Plungeable + - type: PlumbingOutlet + solutionName: buffer + connectedOutlets: true + outletNames: + - outletSouth + - outletEast + - outletWest + - type: SolutionContainerManager + solutions: + buffer: + maxVol: 10 + canReact: false + - type: ExaminableSolution + solution: buffer + - type: NodeContainer + nodes: + outletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + outletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + outletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: UserInterface + interfaces: + enum.PlumbingSynthesizerUiKey.Key: + type: PlumbingSynthesizerBoundUserInterface + - type: ActivatableUI + key: enum.PlumbingSynthesizerUiKey.Key + - type: PowerCellSlot + cellSlotId: cell_slot + - type: ItemSlots + slots: + cell_slot: + name: power-cell-slot-component-slot-name-default + startingItem: PowerCellMedium + - type: ContainerContainer + containers: + cell_slot: !type:ContainerSlot + - type: Charger + slotId: cell_slot + chargeRate: 5 + # passiveDraw: 1 # HL: doesn't exist + - type: ApcPowerReceiver + powerLoad: 1 + - type: ExtensionCableReceiver + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: buffer + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 200 +# ============================================================================= +# Plumbing Disposal - destroys reagents pulled from plumbing network +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingDisposal + name: plumbing disposal + description: Pulls reagents from a south inlet into an internal 200u buffer and destroys them. + components: + - type: Sprite + drawdepth: FloorObjects + sprite: _Starlight/Structures/Piping/Plumbing/plumbers.rsi + layers: + - state: disposal + map: [ "enum.PlumbingVisualLayers.Base" ] + - type: GenericVisualizer + visuals: + enum.PlumbingVisuals.Running: + enum.PlumbingVisualLayers.Base: + True: { state: disposal_working } + False: { state: disposal } + - type: Physics + bodyType: Static + canCollide: false + - type: Fixtures + fixtures: {} + - type: PlumbingDevice + updateInterval: 1 + - type: PlumbingInlet + solutionName: drainBuffer + inletNames: + - inlet + - type: Drain + autoDrain: false + unitsDestroyedPerSecond: 15 + - type: DumpableSolution + solution: drainBuffer + - type: SolutionContainerManager + solutions: + drainBuffer: + maxVol: 200 + canReact: false + - type: ExaminableSolution + solution: drainBuffer + - type: NodeContainer + nodes: + inlet: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: drainBuffer + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 150 + +# ============================================================================= +# Plumbing Drain - floor drain that outputs to plumbing network +# ============================================================================= +- type: entity + parent: PlumbingMachineBase + id: PlumbingDrain + name: plumbing drain + description: A floor drain that absorbs puddles and routes them into the plumbing network instead of disposing them. + placement: + mode: SnapgridCenter + components: + - type: Sprite + drawdepth: FloorObjects + sprite: Objects/Specific/Janitorial/drain.rsi + layers: + - state: icon + - map: [ "enum.SolutionContainerLayers.Fill" ] + state: fill-1 + visible: false + - type: Physics + bodyType: Static + canCollide: false + - type: Fixtures + fixtures: {} + - type: AmbientSound + enabled: false + volume: -8 + range: 8 + sound: + path: /Audio/Ambience/Objects/drain.ogg + - type: Drain + unitsDestroyedPerSecond: 0 + - type: DumpableSolution + solution: drainBuffer + - type: Appearance + - type: SolutionContainerVisuals + maxFillLevels: 1 + fillBaseName: fill- + solutionName: drainBuffer + - type: PlumbingOutlet + solutionName: drainBuffer + connectedOutlets: true + outletNames: + - outletNorth + - outletEast + - outletSouth + - outletWest + - type: SolutionContainerManager + solutions: + drainBuffer: + maxVol: 400 + - type: NodeContainer + nodes: + outletNorth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: North + outletEast: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: East + outletSouth: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: South + outletWest: + !type:PlumbingNode + nodeGroupID: Plumbing + pipeDirection: West + - type: ExaminableSolution + solution: drainBuffer + - type: Destructible + thresholds: + - trigger: + !type:DamageTrigger + damage: 100 + behaviors: + - !type:SpillBehavior + solution: drainBuffer + - !type:DoActsBehavior + acts: ["Destruction"] + - type: StaticPrice + price: 150 diff --git a/Resources/Prototypes/_StarLight/Guidebook/engineering.yml b/Resources/Prototypes/_StarLight/Guidebook/engineering.yml new file mode 100644 index 00000000000..73de6b43ba8 --- /dev/null +++ b/Resources/Prototypes/_StarLight/Guidebook/engineering.yml @@ -0,0 +1,18 @@ +# Plumbing guidebook entries +- type: guideEntry + id: StarlightPlumbing + name: guide-entry-plumbing + text: "/ServerInfo/_StarLight/Guidebook/Engineering/Plumbing.xml" + children: + - PlumbingFlow + - PlumbingMachines + +- type: guideEntry + id: PlumbingFlow + name: guide-entry-plumbingflow + text: "/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingFlow.xml" + +- type: guideEntry + id: PlumbingMachines + name: guide-entry-plumbingmachines + text: "/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingMachines.xml" diff --git a/Resources/Prototypes/_StarLight/RPLD/rpld.yml b/Resources/Prototypes/_StarLight/RPLD/rpld.yml new file mode 100644 index 00000000000..e7d4672cb7e --- /dev/null +++ b/Resources/Prototypes/_StarLight/RPLD/rpld.yml @@ -0,0 +1,220 @@ +# ============================================================================= +# RPLD (Rapid Plumbing Device) - RCD prototypes for plumbing placement +# ============================================================================= + +# ----------------------------------------------------------------------------- +# Category: PlumbingDucts +# ----------------------------------------------------------------------------- + +- type: rcd + id: PlumbingRpldDuctStraight + category: PlumbingDucts + sprite: /Textures/_Starlight/Interface/Radial/RPLD/duct_straight.png + mode: ConstructObject + prototype: PlumbingDuctStraight + cost: 1 + delay: 0 + rotation: User + # hasLayers: true # HL: doesn't exist + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldDuctBend + category: PlumbingDucts + sprite: /Textures/_Starlight/Interface/Radial/RPLD/duct_bend.png + mode: ConstructObject + prototype: PlumbingDuctBend + cost: 1 + delay: 0 + rotation: User + # hasLayers: true # HL: doesn't exist + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldDuctTJunction + category: PlumbingDucts + sprite: /Textures/_Starlight/Interface/Radial/RPLD/duct_tjunction.png + mode: ConstructObject + prototype: PlumbingDuctTJunction + cost: 1 + delay: 0 + rotation: User + # hasLayers: true # HL: doesn't exist + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldDuctFourway + category: PlumbingDucts + sprite: /Textures/_Starlight/Interface/Radial/RPLD/duct_fourway.png + mode: ConstructObject + prototype: PlumbingDuctFourway + cost: 1 + delay: 0 + rotation: User + # hasLayers: true # HL: doesn't exist + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldDuctManifold + category: PlumbingDucts + sprite: /Textures/_Starlight/Interface/Radial/RPLD/duct_manifold.png + mode: ConstructObject + prototype: PlumbingDuctManifold + cost: 1 + delay: 0 + rotation: User + # hasLayers: true # HL: doesn't exist + fx: EffectRCDConstruct0 + +# ----------------------------------------------------------------------------- +# Category: PlumbingSupply +# ----------------------------------------------------------------------------- + +- type: rcd + id: PlumbingRpldInput + category: PlumbingSupply + sprite: /Textures/_Starlight/Interface/Radial/RPLD/pipe_input.png + mode: ConstructObject + prototype: PlumbingInput + cost: 1 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldTank + category: PlumbingSupply + sprite: /Textures/_Starlight/Interface/Radial/RPLD/tank.png + mode: ConstructObject + prototype: PlumbingTank + cost: 2 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldBuffer + category: PlumbingSupply + sprite: /Textures/_Starlight/Interface/Radial/RPLD/buffer_tank.png + mode: ConstructObject + prototype: PlumbingBuffer + cost: 2 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldOutput + category: PlumbingSupply + sprite: /Textures/_Starlight/Interface/Radial/RPLD/pipe_output.png + mode: ConstructObject + prototype: PlumbingOutput + cost: 1 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldSink + category: PlumbingSupply + sprite: /Textures/_Starlight/Interface/Radial/RPLD/sink.png + mode: ConstructObject + prototype: PlumbingSink + cost: 2 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldDrain + category: PlumbingSupply + sprite: /Textures/_Starlight/Interface/Radial/RPLD/drain.png + mode: ConstructObject + prototype: PlumbingDrain + cost: 1 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldDisposal + category: PlumbingSupply + sprite: /Textures/_Starlight/Interface/Radial/RPLD/disposal.png + mode: ConstructObject + prototype: PlumbingDisposal + cost: 1 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +# ----------------------------------------------------------------------------- +# Category: PlumbingProduction +# ----------------------------------------------------------------------------- + +- type: rcd + id: PlumbingRpldFilter + category: PlumbingProduction + sprite: /Textures/_Starlight/Interface/Radial/RPLD/filter.png + mode: ConstructObject + prototype: PlumbingFilter + # mirrorPrototype: PlumbingFilterFlipped # HL: doesn't exist + cost: 1 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldSynthesizer + category: PlumbingProduction + sprite: /Textures/_Starlight/Interface/Radial/RPLD/synthesizer.png + mode: ConstructObject + prototype: PlumbingSynthesizer + cost: 2 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldReactor + category: PlumbingProduction + sprite: /Textures/_Starlight/Interface/Radial/RPLD/reaction_chamber.png + mode: ConstructObject + prototype: PlumbingReactor + cost: 3 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldPillPress + category: PlumbingProduction + sprite: /Textures/_Starlight/Interface/Radial/RPLD/pill_press.png + mode: ConstructObject + prototype: PlumbingPillPress + cost: 3 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 + +- type: rcd + id: PlumbingRpldSmartDispenser + category: PlumbingProduction + sprite: /Textures/_Starlight/Interface/Radial/RPLD/smart_fridge.png + mode: ConstructObject + prototype: PlumbingSmartDispenser + cost: 3 + delay: 0 + collisionMask: MachineMask + rotation: User + fx: EffectRCDConstruct0 diff --git a/Resources/Prototypes/_StarLight/tags.yml b/Resources/Prototypes/_StarLight/tags.yml index db020dd46a0..2d2598bbdc4 100644 --- a/Resources/Prototypes/_StarLight/tags.yml +++ b/Resources/Prototypes/_StarLight/tags.yml @@ -112,6 +112,9 @@ - type: Tag id: PatchPack +- type: Tag + id: PlumbingDuct + - type: Tag id: PowerCellTiny diff --git a/Resources/ServerInfo/Guidebook/Engineering/PlumbingMachines.xml b/Resources/ServerInfo/Guidebook/Engineering/PlumbingMachines.xml new file mode 100644 index 00000000000..429e000f507 --- /dev/null +++ b/Resources/ServerInfo/Guidebook/Engineering/PlumbingMachines.xml @@ -0,0 +1,108 @@ + + # Plumbing Machines + All plumbing machines are placed with the RPLD. Machines that require [color=#a4885c]power[/color] must be within range of an APC. + + + + + + + ## Input and Output + + + [color=#999999][italic]Getting reagents into and out of the network[/italic][/color] + + + The [color=#a4885c]Plumbing Input[/color] is a small tank you pour reagents into by hand. Other machines pull from it via the network. Connects in all directions. + + The [color=#a4885c]Plumbing Output[/color] is a small tank you can draw reagents from using a container. It pulls reagents from the network into its buffer. Connects in all directions. + + + + + + + ## Sink and Drain + + + [color=#999999][italic]The plumbing classics.[/italic][/color] + + + The [color=#a4885c]Plumbing Sink[/color] is more or less a combined input and output. Reagents drawn in from its inlets can be used to fill containers from its facet, and dumping reagents down the drain sends them into the network via its outlet. + + The [color=#a4885c]Plumbing Drain[/color] is a floor drain that absorbs puddles and routes them into the plumbing network. Connects in all directions. + + + + + + ## Tank + + + [color=#999999][italic]Buffering reagents in the network[/italic][/color] + + + The [color=#a4885c]Plumbing Tank[/color] stores up to [color=#a4885c]400u[/color] of reagents. Has one inlet and three outlets. Use tanks to buffer reagents between production stages or store large amounts of reagents. + + + + + + ## Filter + + + [color=#999999][italic]Splitting reagents by type[/italic][/color] + + + The [color=#a4885c]Plumbing Filter[/color] separates specific reagents from the network. Set which reagents to filter via its UI. Has one inlet and two outlets, one outlet for filtered reagents and one for everything else. When disabled in the UI all reagents passthrough. Can be flipped via the RPLD. + + + + + + ## Reactor + + + [color=#999999][italic]Triggering chemical reactions automatically[/italic][/color] + + + The [color=#a4885c]Plumbing Reactor[/color] pulls specific reagents from its inlet in configured quantities, heats them, and triggers reactions. Products are moved to the outlet. Has one inlet and one outlet. Set target reagents and quantities via the UI. Requires power. Use a plunger to clear stuck reagents. + + + + + + ## Pill Press + + + [color=#999999][italic]Automated pill and patch production[/italic][/color] + + + The [color=#a4885c]Plumbing Pill Press[/color] pulls reagents and presses them into pills or patches at a configurable dosage. Has one main inlet that pulls from the network normally, plus two optional mixing inlets that allow ratio-controlled mixing — set a percentage for each side to blend reagents from two separate networks. Toggle between pill and patch output via the UI. Requires power. + + + + + + ## Synthesizer + + + [color=#999999][italic]Generating reagents from power[/italic][/color] + + + The [color=#a4885c]Plumbing Synthesizer[/color] generates basic reagents from an internal battery. Select a reagent from the UI and toggle it on. The battery charges while the machine is powered and drains as reagents are synthesized. Different reagents have different power costs. + + Available reagents: Iron, Carbon, Copper, Hydrogen, Oxygen, Sugar, Silicon, Phosphorus. + + + + + + ## Smart Fridge + + + [color=#999999][italic]Storing and dispensing reagents via labeled jugs[/italic][/color] + + + The [color=#a4885c]Plumbing Smart Fridge[/color] pulls all reagents from the network and stores up to [color=#a4885c]200u[/color] of each type. Use a [color=#a4885c]labeled jug[/color] on the fridge to fill it with the matching reagent. Connects in all directions. Requires power. + diff --git a/Resources/ServerInfo/Guidebook/Medical/Chemist.xml b/Resources/ServerInfo/Guidebook/Medical/Chemist.xml index 6712e15dcea..217f7418439 100644 --- a/Resources/ServerInfo/Guidebook/Medical/Chemist.xml +++ b/Resources/ServerInfo/Guidebook/Medical/Chemist.xml @@ -6,6 +6,8 @@ While chemists primarily make medications, there's a very wide variety of chemic [textlink="Click here to see a complete list of chemicals." link="Chemicals"] +For automated chemical production, see [textlink="Plumbing" link="Plumbing"]. + ## Equipment: diff --git a/Resources/ServerInfo/_StarLight/Guidebook/Engineering/Plumbing.xml b/Resources/ServerInfo/_StarLight/Guidebook/Engineering/Plumbing.xml new file mode 100644 index 00000000000..e81a56535f2 --- /dev/null +++ b/Resources/ServerInfo/_StarLight/Guidebook/Engineering/Plumbing.xml @@ -0,0 +1,51 @@ + + # Plumbing + Plumbing is a reagent piping system that lets you build fluid supply systems and automated chemical factories. Fluid ducts connect machines together into networks, moving reagents between them without manual intervention. + + + + + + ## Getting Started + Plumbing is built using the [color=#a4885c]RPLD[/color] (Rapid Plumbing Device), which works like an RCD but for plumbing. It can place fluid ducts and all plumbing machines (but not all machines with plumbing connectors). Select what to build from its radial menu. + + All plumbing machines and ducts are [color=#a4885c]rotatable[/color]. Use the rotation key before or after placing to orient inlets and outlets correctly. Machines must be oriented so their connectors line up with adjacent ducts. Most plumbing machines are rotatable while anchored. + + ## Fluid Ducts + Fluid ducts are pipes that carry reagents between machines. They are similar to atmos pipes, place them with the RPLD and they automatically connect to adjacent ducts and machines to form a [color=#a4885c]plumbing duct network[/color]. Ducts hide under floor tiles. + + Plumbing ducts support [color=#a4885c]three duct layers[/color]: Primary, Secondary, and Tertiary. Use the RPLD mode switch (or free mode guide dots) to choose which layer a duct is placed on. + + There are five duct variants: + + + + + + + + + + The [color=#a4885c]Manifold[/color] bridges ducts connected to each of its sides. It can connect separate ducts across all three layers. + + ## Connector Colors + Each machine's connectors are color-coded: + - [color=#ff5959]Red[/color] connectors are [bold]inlets[/bold]: the machine pulls reagents from the network through these. + - [color=#5999ff]Blue[/color] connectors are [bold]outlets[/bold]: other machines can pull reagents from this machine through these. + - [color=#59e659]Green[/color] connectors are [bold]mixing inlets[/bold]: specialized inlets for ratio-controlled mixing (pill press). + + Connected connectors appear as smooth joints. Disconnected connectors appear jagged. + + ## Plunger + Most machines with internal buffers are [color=#a4885c]plungeable[/color]. Use a plunger on them to flush their contents onto the floor. Useful for clearing stuck reagents. + + ## Reagent Flow + See [textlink="Reagent Flow" link="PlumbingFlow"] for details on how reagents move through networks, pull mechanics, and distribution. + + ## Machines + See [textlink="Plumbing Machines" link="PlumbingMachines"] for details on each machine. + + Some non-plumbing machines also support plumbing connections, including the [color=#a4885c]ChemMaster[/color], [color=#a4885c]Chemical Dispenser[/color], and [color=#a4885c]Industrial Reagent Grinder[/color]. + + + diff --git a/Resources/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingFlow.xml b/Resources/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingFlow.xml new file mode 100644 index 00000000000..ffc730bf9ee --- /dev/null +++ b/Resources/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingFlow.xml @@ -0,0 +1,45 @@ + + # Reagent Flow + Understanding how reagents move through plumbing networks is key to building efficient factories. + + ## Networks + A [color=#a4885c]plumbing network[/color] is a group of machines and ducts connected together through their connectors. Reagents can only flow between machines on the [bold]same[/bold] network. + + Plumbing ducts support [color=#a4885c]three layers[/color] (Primary, Secondary, Tertiary). Ducts only connect to other ducts/nodes on the same layer unless a bridging component (such as a manifold) links paths. + + Each [color=#ff5959]inlet[/color] connector on a machine forms its own [bold]independent network[/bold]. This means if a machine has multiple inlet connectors, each one connects to a separate network. Pipes attached to different inlets on the same machine [bold]do not bridge[/bold]. + + [color=#5999ff]Outlet[/color] connectors on the other hand can be connected and bridge networks. Most machines bridge outlets into one network, but some (currently only the plumbing buffer) intentionally keep outlets isolated. Check machine behavior when designing branches. + + ## Pull-Based Flow + Plumbing uses a [color=#a4885c]pull-based[/color] model, reagents don't flow on their own. A machine with an inlet [bold]actively pulls[/bold] reagents from the outlets of other machines on the same network. If nothing is pulling, nothing moves. + + This means: + - An [color=#a4885c]Input[/color] won't push reagents anywhere by itself. Another machine must pull from it. + - A [color=#a4885c]Synthesizer[/color] generates reagents into its buffer, but they sit there until something pulls. + - A [color=#a4885c]Tank[/color] pulls from its inlet network and stores reagents. Other machines then pull from the tank's outlet network. + + ## Round-Robin Distribution + When a machine pulls reagents and there are [bold]multiple outlets[/bold] on the same network (e.g., two synthesizers feeding a tank), it uses round-robin distribution. Each update tick, it starts pulling from a different outlet, cycling through them fairly. + + ## Transfer Rate + Machines pull according to their configured transfer amount and update interval (generally 20u every 2 seconds). That pull budget is shared across all of a machine's inlets; adding more inlets splits access paths, not total pull budget. + + ## Reactor: Targeted Pulling + The [color=#a4885c]Reactor[/color] is special, it pulls [bold]specific reagents[/bold] rather than everything. It fills each target reagent fully before moving to the next. If you set targets of 30u Iron and 20u Carbon, it will pull all 30u of Iron first, then pull Carbon. + + ## Filter: Selective Routing + The [color=#a4885c]Filter[/color] has one inlet and two outlets. It classifies intake into separate filtered and passthrough lanes, then controls which reagents are available on which outlet: + - [bold]Filtered outlet[/bold]: Only provides the reagents you've selected. + - [bold]Passthrough outlet[/bold]: Only provides reagents you [italic]haven't[/italic] selected. + + Because the lanes are separate, passthrough buildup will not prevent filtered reagents from being pulled into the machine. + + ## Pill Press: Mixing Mode + In [color=#a4885c]mixing mode[/color], the pill press ignores its main inlet and instead pulls from its [color=#59e659]mixing inlets[/color]. Each mixing inlet pulls from its own separate network into a staging area. Once both staging areas have enough reagent, they combine and press a pill at the configured ratio. + + ## Tips + - Use the [color=#a4885c]plunger[/color] to clear stuck reagents from any machine's buffer. + - Machines only pull when they have space in their buffer. A full buffer stops pulling until reagents are pulled from it. + - Use a buffer tank when you want reactor product fed back into a supply network for other reactors to use while also keeping a separate product output network for collection (dispenser/ChemMaster/etc.). + diff --git a/Resources/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingMachines.xml b/Resources/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingMachines.xml new file mode 100644 index 00000000000..2e2a66cc9ee --- /dev/null +++ b/Resources/ServerInfo/_StarLight/Guidebook/Engineering/PlumbingMachines.xml @@ -0,0 +1,136 @@ + + # Plumbing Machines + All plumbing machines are placed with the RPLD. Machines that require [color=#a4885c]power[/color] must be within range of an APC. + + + + + + + ## Input and Output + + + [color=#999999][italic]Getting reagents into and out of the network[/italic][/color] + + + The [color=#a4885c]Plumbing Input[/color] is a small tank you pour reagents into by hand. Other machines pull from it via the network. Connects in all directions. + + The [color=#a4885c]Plumbing Output[/color] is a small tank you can draw reagents from using a container. It pulls reagents from the network into its buffer. Connects in all directions. + + + + + + + ## Sink and Drain + + + [color=#999999][italic]The plumbing classics.[/italic][/color] + + + The [color=#a4885c]Plumbing Sink[/color] is more or less a combined input and output. Reagents drawn in from its inlets can be used to fill containers from its facet, and dumping reagents down the drain sends them into the network via its outlet. + + The [color=#a4885c]Plumbing Drain[/color] is a floor drain that absorbs puddles and routes them into the plumbing network. Connects in all directions. + + + + + + ## Tank + + + [color=#999999][italic]Buffering reagents in the network[/italic][/color] + + + The [color=#a4885c]Plumbing Tank[/color] stores up to [color=#a4885c]2000u[/color] of reagents. Has one inlet and three outlets. Use tanks to buffer reagents between production stages or store large amounts of reagents. + + + + + + ## Buffer + + + [color=#999999][italic]Aww cute![/italic][/color] + + + The [color=#a4885c]Plumbing Buffer[/color] stores up to [color=#a4885c]200u[/color] in a low-profile tank that can be walked over. It has one inlet and three outlets, with unconnected outlets for supplying seperate networks. + + + + + + ## Filter + + + [color=#999999][italic]Splitting reagents by type[/italic][/color] + + + The [color=#a4885c]Plumbing Filter[/color] separates specific reagents from the network. Set which reagents to filter via its UI. It has one inlet and two outlets: + - [bold]Filtered outlet[/bold] for selected reagents. + - [bold]Passthrough outlet[/bold] for non-selected reagents. + + The filter sorts incoming reagents into filtered and unfiltered internal containers, which can be pulled from the filtered and passthrough outlets respectively. It is capable of filtering off up to 4 unique reagents at a time. When disabled in the UI, all intake is treated as passthrough. Can be flipped via the RPLD. + + + + + + ## Reactor + + + [color=#999999][italic]Triggering chemical reactions automatically[/italic][/color] + + + The [color=#a4885c]Plumbing Reactor[/color] pulls specific reagents from its inlet in configured quantities, heats them, and triggers reactions. Products are moved to the outlet. Has one inlet and one outlet. Set target reagents and quantities via the UI. Requires power. Use a plunger to clear stuck reagents. + + + + + + ## Pill Press + + + [color=#999999][italic]Automated pill and patch production[/italic][/color] + + + The [color=#a4885c]Plumbing Pill Press[/color] pulls reagents and presses them into pills or patches at a configurable dosage. Has one main inlet that pulls from the network normally, plus two optional mixing inlets that allow ratio-controlled mixing — set a percentage for each side to blend reagents from two separate networks. Toggle between pill and patch output via the UI. Requires power. + + + + + + ## Synthesizer + + + [color=#999999][italic]Generating reagents from power[/italic][/color] + + + The [color=#a4885c]Plumbing Synthesizer[/color] generates basic reagents from an internal battery. Select a reagent from the UI and toggle it on. The battery charges while the machine is powered and drains as reagents are synthesized. Different reagents have different power costs. + + Available reagents: Iron, Carbon, Copper, Hydrogen, Oxygen, Sugar, Silicon, Phosphorus. + + + + + + ## Smart Dispenser + + + [color=#999999][italic]Storing and dispensing reagents via labeled jugs[/italic][/color] + + + The [color=#a4885c]Plumbing Smart Dispenser[/color] pulls all reagents from the network and stores up to [color=#a4885c]200u[/color] of each type. It pulls [bold]40u per update[/bold], which is [bold]2x[/bold] the standard [bold]20u[/bold] pull rate used by most plumbing machines. Use a [color=#a4885c]labeled jug[/color] on the dispenser to fill it with the matching reagent. Connects in all directions. Requires power. + + + + + + ## Disposal + + + [color=#999999][italic]Vaporizes unwanted reagents[/italic][/color] + + + The [color=#a4885c]Plumbing Disposal[/color] has one inlet which it uses to pull reagents into an internal buffer, which are then destroyed over time. Use it to cleanly remove unwanted reagents from a duct network. + diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/buffer_tank.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/buffer_tank.png new file mode 100644 index 00000000000..0d8ffea0d25 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/buffer_tank.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/category_ducts.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/category_ducts.png new file mode 100644 index 00000000000..cb7b16d6565 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/category_ducts.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/category_machines.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/category_machines.png new file mode 100644 index 00000000000..ec46d796e70 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/category_machines.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/disposal.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/disposal.png new file mode 100644 index 00000000000..9d70555538b Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/disposal.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/disposer.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/disposer.png new file mode 100644 index 00000000000..c64665b3513 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/disposer.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/drain.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/drain.png new file mode 100644 index 00000000000..b939e31b8b1 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/drain.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_bend.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_bend.png new file mode 100644 index 00000000000..67ea1e04eed Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_bend.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_fourway.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_fourway.png new file mode 100644 index 00000000000..cb7b16d6565 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_fourway.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_manifold.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_manifold.png new file mode 100644 index 00000000000..aa6829db270 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_manifold.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_straight.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_straight.png new file mode 100644 index 00000000000..a8ee8fba3ff Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_straight.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_tjunction.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_tjunction.png new file mode 100644 index 00000000000..8933811269b Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/duct_tjunction.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/filter.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/filter.png new file mode 100644 index 00000000000..9f933c7e58d Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/filter.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/pill_press.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/pill_press.png new file mode 100644 index 00000000000..5b437bf6960 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/pill_press.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/pipe_input.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/pipe_input.png new file mode 100644 index 00000000000..a7bb070a499 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/pipe_input.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/pipe_output.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/pipe_output.png new file mode 100644 index 00000000000..d811eb86061 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/pipe_output.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/reaction_chamber.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/reaction_chamber.png new file mode 100644 index 00000000000..b2127e648b4 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/reaction_chamber.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/sink.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/sink.png new file mode 100644 index 00000000000..2728aafa276 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/sink.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/smart_fridge.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/smart_fridge.png new file mode 100644 index 00000000000..970a0cc29d3 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/smart_fridge.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/synthesizer.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/synthesizer.png new file mode 100644 index 00000000000..29c06258482 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/synthesizer.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/tank.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/tank.png new file mode 100644 index 00000000000..ec46d796e70 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/tank.png differ diff --git a/Resources/Textures/_Starlight/Interface/Radial/RPLD/tap_output.png b/Resources/Textures/_Starlight/Interface/Radial/RPLD/tap_output.png new file mode 100644 index 00000000000..8dc7bfdb903 Binary files /dev/null and b/Resources/Textures/_Starlight/Interface/Radial/RPLD/tap_output.png differ diff --git a/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/icon.png b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/icon.png new file mode 100644 index 00000000000..6b420de2de1 Binary files /dev/null and b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/icon.png differ diff --git a/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/inhand-left.png b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/inhand-left.png new file mode 100644 index 00000000000..690c6fea6fd Binary files /dev/null and b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/inhand-left.png differ diff --git a/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/inhand-right.png b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/inhand-right.png new file mode 100644 index 00000000000..4e7c93af959 Binary files /dev/null and b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/inhand-right.png differ diff --git a/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/meta.json b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/meta.json new file mode 100644 index 00000000000..c21625b1f0c --- /dev/null +++ b/Resources/Textures/_Starlight/Objects/Tools/rpld.rsi/meta.json @@ -0,0 +1,22 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "Recolored from CEV-Eris RPD sprites", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "icon" + }, + { + "name": "inhand-left", + "directions": 4 + }, + { + "name": "inhand-right", + "directions": 4 + } + ] +} diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductBend.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductBend.png new file mode 100644 index 00000000000..5c56208d548 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductBend.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductConnector.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductConnector.png new file mode 100644 index 00000000000..597a7f2fe58 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductConnector.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductFourway.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductFourway.png new file mode 100644 index 00000000000..e920791d890 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductFourway.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductStraight.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductStraight.png new file mode 100644 index 00000000000..00033a3df21 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductStraight.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductTJunction.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductTJunction.png new file mode 100644 index 00000000000..199b7859086 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/ductTJunction.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/meta.json b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/meta.json new file mode 100644 index 00000000000..7e588ca19cf --- /dev/null +++ b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/meta.json @@ -0,0 +1,52 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "TGstation", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "ductBend", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductConnector", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductFourway", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductStraight", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductTJunction", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "storageBend", + "copyright": "TGStation" + }, + { + "name": "storageFourway", + "copyright": "TGStation" + }, + { + "name": "storageStraight", + "copyright": "TGStation" + }, + { + "name": "storageTjunction", + "copyright": "TGStation" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageBend.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageBend.png new file mode 100644 index 00000000000..0fb7161e186 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageBend.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageFourway.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageFourway.png new file mode 100644 index 00000000000..3b915b5918e Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageFourway.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageStraight.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageStraight.png new file mode 100644 index 00000000000..5806fd083c4 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageStraight.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageTjunction.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageTjunction.png new file mode 100644 index 00000000000..da30f800f37 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts.rsi/storageTjunction.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductBend.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductBend.png new file mode 100644 index 00000000000..33a2c053a0b Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductBend.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductConnector.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductConnector.png new file mode 100644 index 00000000000..6452ea8c5bf Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductConnector.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductFourway.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductFourway.png new file mode 100644 index 00000000000..26ef3525d37 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductFourway.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductStraight.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductStraight.png new file mode 100644 index 00000000000..d763c024028 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductStraight.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductTJunction.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductTJunction.png new file mode 100644 index 00000000000..57a63059d4d Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/ductTJunction.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/meta.json b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/meta.json new file mode 100644 index 00000000000..d382535b1ac --- /dev/null +++ b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt1.rsi/meta.json @@ -0,0 +1,36 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "TGstation", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "ductBend", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductConnector", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductFourway", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductStraight", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductTJunction", + "directions": 4, + "copyright": "TGStation" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductBend.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductBend.png new file mode 100644 index 00000000000..fbecf739e24 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductBend.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductConnector.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductConnector.png new file mode 100644 index 00000000000..1f74a7736d3 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductConnector.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductFourway.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductFourway.png new file mode 100644 index 00000000000..481f00a677f Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductFourway.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductStraight.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductStraight.png new file mode 100644 index 00000000000..211f292371f Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductStraight.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductTJunction.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductTJunction.png new file mode 100644 index 00000000000..8d97a2ee8bb Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/ductTJunction.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/meta.json b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/meta.json new file mode 100644 index 00000000000..d382535b1ac --- /dev/null +++ b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/fluid_ducts_alt2.rsi/meta.json @@ -0,0 +1,36 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "TGstation", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "ductBend", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductConnector", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductFourway", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductStraight", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductTJunction", + "directions": 4, + "copyright": "TGStation" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/bottler.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/bottler.png new file mode 100644 index 00000000000..f902a47a5a2 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/bottler.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/buffer_tank.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/buffer_tank.png new file mode 100644 index 00000000000..9cf3c7cce7c Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/buffer_tank.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal.png new file mode 100644 index 00000000000..8a156380989 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal_working.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal_working.png new file mode 100644 index 00000000000..a52eb6baf5b Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/disposal_working.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector.png new file mode 100644 index 00000000000..f80ebbb016f Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector_connected.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector_connected.png new file mode 100644 index 00000000000..b02d4a01e14 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/ductConnector_connected.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filter.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filter.png new file mode 100644 index 00000000000..4daac73a063 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filter.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filterF.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filterF.png new file mode 100644 index 00000000000..d00df89c66a Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/filterF.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/meta.json b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/meta.json new file mode 100644 index 00000000000..a512fd2bb82 --- /dev/null +++ b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/meta.json @@ -0,0 +1,118 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "TGStation", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "bottler", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "disposal", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "disposal_working", + "directions": 4, + "delays": [ + [ 0.1, 0.1, 0.1, 0.1, 0.1 ], + [ 0.1, 0.1, 0.1, 0.1, 0.1 ], + [ 0.1, 0.1, 0.1, 0.1, 0.1 ], + [ 0.1, 0.1, 0.1, 0.1, 0.1 ] + ], + "copyright": "TGStation" + }, + { + "name": "ductConnector", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "ductConnector_connected", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "filter", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "filterF", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "pill_press", + "directions": 4, + "delays": [ + [ 0.1, 0.1, 0.1 ], + [ 0.1, 0.1, 0.1 ], + [ 0.1, 0.1, 0.1 ], + [ 0.1, 0.1, 0.1 ] + ], + "copyright": "TGStation" + }, + { + "name": "pill_press_off", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "pipe_input", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "pipe_output", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "reaction_chamber", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "reaction_chamber_on", + "directions": 4, + "delays": [ [ 0.2, 0.2, 0.2, 0.2 ], [ 0.2, 0.2, 0.2, 0.2 ], [ 0.2, 0.2, 0.2, 0.2 ], [ 0.2, 0.2, 0.2, 0.2 ] ], + "copyright": "TGStation" + }, + { + "name": "synthesizer", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "synthesizer_inactive", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "synthesizer_overlay", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "tank", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "buffer_tank", + "directions": 4, + "copyright": "TGStation" + }, + { + "name": "tap_output", + "copyright": "TGStation" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press.png new file mode 100644 index 00000000000..b00439fb855 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press_off.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press_off.png new file mode 100644 index 00000000000..b462921a6cc Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pill_press_off.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_input.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_input.png new file mode 100644 index 00000000000..295b90ebf07 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_input.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_output.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_output.png new file mode 100644 index 00000000000..7b059277459 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/pipe_output.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber.png new file mode 100644 index 00000000000..df30be70209 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber_on.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber_on.png new file mode 100644 index 00000000000..794e9d7e64c Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/reaction_chamber_on.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer.png new file mode 100644 index 00000000000..e89dfeac9db Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_inactive.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_inactive.png new file mode 100644 index 00000000000..0a740e719d6 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_inactive.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_overlay.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_overlay.png new file mode 100644 index 00000000000..9863f76829c Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/synthesizer_overlay.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tank.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tank.png new file mode 100644 index 00000000000..7b500de2dc6 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tank.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tap_output.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tap_output.png new file mode 100644 index 00000000000..0a0702ba1d3 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbers.rsi/tap_output.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi/duct_manifold.png b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi/duct_manifold.png new file mode 100644 index 00000000000..11f22986c27 Binary files /dev/null and b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi/duct_manifold.png differ diff --git a/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi/meta.json b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi/meta.json new file mode 100644 index 00000000000..142ff4add0e --- /dev/null +++ b/Resources/Textures/_Starlight/Structures/Piping/Plumbing/plumbing_manifold.rsi/meta.json @@ -0,0 +1,16 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "FeralCreature (GitHub)", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "duct_manifold", + "directions": 4, + "copyright": "FeralCreature" + } + ] +}