Migration

.github/ISSUE_TEMPLATE/config.yml

@@ -2,6 +2,3 @@ contact_links:
   - name: Report a Security Vulnerability
     url: https://github.com/space-wizards/space-station-14/blob/master/SECURITY.md
     about: Please report security vulnerabilities privately so we can fix them before they are publicly disclosed.
-  - name: Request a Feature
-    url: https://discord.gg/rGvu9hKffJ
-    about: Submit feature requests on our Discord server (https://discord.gg/rGvu9hKffJ).

Content.Client/Overlays/StaticSystem.cs

@@ -0,0 +1,134 @@
+using Content.Shared.Inventory;
+using Content.Shared.Inventory.Events;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using Content.Shared.Overlays;
+using Robust.Shared.Timing;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Content.Shared.Clothing;
+
+namespace Content.Client.Overlays
+{
+    public sealed class StaticViewerHudSystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    private ShaderInstance _staticViewerShader = null!;
+private StaticViewerOverlay _staticViewerOverlay = null!;
+
+
+    public StaticViewerHudSystem()
+    {
+        IoCManager.InjectDependencies(this);
+    }
+
+    public override void Initialize()
+    {
+        _staticViewerShader = _prototypeManager.Index<ShaderPrototype>("Grainy").Instance();
+
+        _staticViewerOverlay = new StaticViewerOverlay(_staticViewerShader, _entityManager, _player);
+
+        SubscribeLocalEvent<StaticViewerComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<StaticViewerComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<StaticViewerComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<StaticViewerComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
+        SubscribeLocalEvent<StaticViewerComponent, GotEquippedEvent>(OnEquipped);
+        SubscribeLocalEvent<StaticViewerComponent, GotUnequippedEvent>(OnUnequipped);
+    }
+
+    private void OnEquipped(Entity<StaticViewerComponent> ent, ref GotEquippedEvent args)
+    {
+        EnsureComp<StaticViewerComponent>(args.Equipee);
+    }
+
+    private void OnUnequipped(Entity<StaticViewerComponent> ent, ref GotUnequippedEvent args)
+    {
+        _entityManager.RemoveComponent<StaticViewerComponent>(args.Equipee);
+    }
+
+    private void OnPlayerAttached(Entity<StaticViewerComponent> ent, ref LocalPlayerAttachedEvent args)
+    {
+        _overlayMan.AddOverlay(_staticViewerOverlay);
+    }
+
+    private void OnPlayerDetached(Entity<StaticViewerComponent> ent, ref LocalPlayerDetachedEvent args)
+    {
+        _overlayMan.RemoveOverlay(_staticViewerOverlay);
+    }
+
+    private void OnInit(Entity<StaticViewerComponent> ent, ref ComponentInit args)
+    {
+        if (_player.LocalEntity == ent)
+        {
+            _overlayMan.AddOverlay(_staticViewerOverlay);
+        }
+    }
+
+    private void OnShutdown(Entity<StaticViewerComponent> ent, ref ComponentShutdown args)
+    {
+        if (_player.LocalEntity == ent)
+        {
+            _overlayMan.RemoveOverlay(_staticViewerOverlay);
+        }
+    }
+}
+
+   public sealed class StaticViewerOverlay : Overlay
+{
+    private readonly ShaderInstance _shaderInstance;
+    private readonly IEntityManager _entityManager;
+    private readonly IPlayerManager _playerManager;
+
+    public StaticViewerOverlay(ShaderInstance shaderInstance, IEntityManager entityManager, IPlayerManager playerManager)
+    {
+        _shaderInstance = shaderInstance;
+        _entityManager = entityManager;
+        _playerManager = playerManager;
+    }
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+    public override bool RequestScreenTexture => true;
+
+    protected override bool BeforeDraw(in OverlayDrawArgs args)
+    {
+        var playerEntity = _playerManager.LocalEntity;
+
+        if (!playerEntity.HasValue)
+            return false;
+
+        if (!_entityManager.TryGetComponent(playerEntity.Value, out EyeComponent? eyeComp))
+            return false;
+
+        if (args.Viewport.Eye != eyeComp.Eye)
+            return false;
+
+        return true;
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (ScreenTexture == null)
+            return;
+
+        var handle = args.WorldHandle;
+
+        // Duplicate the shader instance to make it mutable
+        var mutableShaderInstance = _shaderInstance.Duplicate();
+
+        mutableShaderInstance.SetParameter("SCREEN_TEXTURE", ScreenTexture);
+
+        // Use the duplicated mutable shader
+        handle.UseShader(mutableShaderInstance);
+        handle.DrawRect(args.WorldBounds, Color.White);
+        handle.UseShader(null);
+    }
+}
+}
+

Content.Server/Atmos/Components/InGasComponent.cs

@@ -0,0 +1,68 @@
+using Content.Shared.Alert;
+using Content.Shared.Damage;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Prototypes;
+using Content.Shared.Interaction;
+
+namespace Content.Server.Atmos.Components;
+
+/// <summary>
+/// Component to handle non-breathing gas interactions.
+/// Detects gasses around entities and applies effects. (this is currently for damage to borgs but ¯\_(ツ)_/¯)
+/// </summary>
+[RegisterComponent]
+public sealed partial class InGasComponent : Component
+{
+
+    /// <summary>
+    ///     ID of gas to check for as an int. Defaults to water.
+    /// </summary>
+    [DataField("gasID"), ViewVariables(VVAccess.ReadWrite)]
+    public int GasId = 9;
+
+    ///  <summary>
+    ///     amount of gas needed to trigger effect in mols.
+    /// </summary>
+    [DataField("gasThreshold"), ViewVariables(VVAccess.ReadWrite)]
+    public float GasThreshold = 0.1f;
+
+    /// <summary>
+    ///   Whether the entity is damaged by water.
+    ///   By default things are not
+    /// </summary>
+    [DataField("damagedByGas"), ViewVariables(VVAccess.ReadWrite)]
+    public bool DamagedByGas = false;
+    /// <summary>
+    /// Damage caused by gas contact
+    /// </summary>
+    [DataField("damage"), ViewVariables(VVAccess.ReadWrite)]
+    public DamageSpecifier Damage = default!;
+
+    ///<summary>
+    /// Prevents gibbing from gas damage, same purpose as the barotrauma one
+    /// </summary>
+    [DataField("maxDamage"), ViewVariables(VVAccess.ReadWrite)]
+    public FixedPoint2 MaxDamage = 200;
+
+    /// <summary>
+    /// Used to track when damage starts/stops. Used in logs + the alert.
+    /// </summary>
+    [DataField]
+    public bool TakingDamage = false;
+
+
+     /// <summary>
+    /// Tracks whether something is underwater specifically.
+    /// </summary>
+    [DataField]
+    public bool InWater = false;
+
+    /// <summary>
+    /// The alert to send when the entity is damaged by gas.
+    /// </summary>
+    [DataField]
+    public ProtoId<AlertPrototype> DamageAlert = "ShortCircuit";
+
+    [DataField]
+    public ProtoId<AlertCategoryPrototype> BreathingAlertCategory = "Breathing";
+}

Content.Server/Atmos/Components/InWaterEvent.cs

@@ -0,0 +1,39 @@
+using JetBrains.Annotations;
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Atmos.Components;
+
+namespace Content.Shared.Interaction;
+
+/// <summary>
+/// Raised when an entity enters water in the world.
+/// </summary>
+[PublicAPI]
+public sealed class InWaterEvent : HandledEntityEventArgs
+{
+    /// <summary>
+    /// The entity that entered the water.
+    /// </summary>
+    public EntityUid User { get; }
+
+    public InWaterEvent(EntityUid user)
+    {
+        User = user;
+    }
+}
+
+/// <summary>
+/// Raised when an entity exits water in the world.
+/// </summary>
+[PublicAPI]
+public sealed class OutOfWaterEvent : HandledEntityEventArgs
+{
+    /// <summary>
+    /// The entity that exited the water.
+    /// </summary>
+    public EntityUid User { get; }
+
+    public OutOfWaterEvent(EntityUid user)
+    {
+        User = user;
+    }
+}

Content.Server/Atmos/Components/RustableComponent.cs

@@ -0,0 +1,10 @@
+namespace Content.Server.Atmos.Components;
+
+/// <summary>
+/// A component that describes objects (walls for example) that can be decayed and rusted by seawater
+/// </summary>
+[RegisterComponent]
+public sealed partial class RustableComponent : Component
+{
+
+}

Content.Server/Atmos/EntitySystems/AtmosphereSystem.Commands.cs

@@ -36,7 +36,7 @@ private void FixGridAtmosCommand(IConsoleShell shell, string argstr, string[] ar
            return;
        }
 
-       var mixtures = new GasMixture[7];
+       var mixtures = new GasMixture[8];
        for (var i = 0; i < mixtures.Length; i++)
            mixtures[i] = new GasMixture(Atmospherics.CellVolume) { Temperature = Atmospherics.T20C };
 
@@ -65,6 +65,10 @@ private void FixGridAtmosCommand(IConsoleShell shell, string argstr, string[] ar
        mixtures[6].AdjustMoles(Gas.Nitrogen, Atmospherics.NitrogenMolesStandard);
        mixtures[6].Temperature = 235f; // Little colder than an actual freezer but gives a grace period to get e.g. themomachines set up, should keep warm for a few door openings
 
+       // 7: Water
+       mixtures[7].AdjustMoles(Gas.Water, Atmospherics.WaterMolesStandard);
+       mixtures[7].Temperature = 40f; // god help us all
+
        foreach (var arg in args)
        {
            if (!NetEntity.TryParse(arg, out var netEntity) || !TryGetEntity(netEntity, out var euid))

Content.Server/Atmos/EntitySystems/AtmosphereSystem.HighPressureDelta.cs

@@ -14,12 +14,13 @@ namespace Content.Server.Atmos.EntitySystems
 {
     public sealed partial class AtmosphereSystem
     {
-        private const int SpaceWindSoundCooldownCycles = 75;
+        private const int SpaceWindSoundCooldownCycles = 1000;
 
         private int _spaceWindSoundCooldown = 0;
 
         [ViewVariables(VVAccess.ReadWrite)]
         public string? SpaceWindSound { get; private set; } = "/Audio/Effects/space_wind.ogg";
+        public string? WaterMoveSound { get; private set; } = "/Audio/Effects/water_move.ogg";
 
         private readonly HashSet<Entity<MovedByPressureComponent>> _activePressures = new(8);
 
@@ -93,15 +94,37 @@ private void AddMobMovedByPressure(EntityUid uid, MovedByPressureComponent compo
         private void HighPressureMovements(Entity<GridAtmosphereComponent> gridAtmosphere, TileAtmosphere tile, EntityQuery<PhysicsComponent> bodies, EntityQuery<TransformComponent> xforms, EntityQuery<MovedByPressureComponent> pressureQuery, EntityQuery<MetaDataComponent> metas)
         {
             // TODO ATMOS finish this
+        bool isWaterPresent = false;
+        bool isWaterTooMuch = false;
+
+        if (tile.Air != null)
+        {
+            // Check the moles of gasId 9 (water)
+            if (tile.Air.GetMoles(9) >= 10)  // Adjust the last threshhold as needed
+            {
+                isWaterPresent = true;
+            }
+
+            if (tile.Air.GetMoles(9) >= 120)
+            {
+                isWaterTooMuch = true;
+            }
+
+        }
 
             // Don't play the space wind sound on tiles that are on fire...
             if (tile.PressureDifference > 15 && !tile.Hotspot.Valid)
             {
-                if (_spaceWindSoundCooldown == 0 && !string.IsNullOrEmpty(SpaceWindSound))
+                if (_spaceWindSoundCooldown == 0 && !string.IsNullOrEmpty(SpaceWindSound) && !isWaterPresent && !isWaterTooMuch)
                 {
                     var coordinates = _mapSystem.ToCenterCoordinates(tile.GridIndex, tile.GridIndices);
                     _audio.PlayPvs(SpaceWindSound, coordinates, AudioParams.Default.WithVariation(0.125f).WithVolume(MathHelper.Clamp(tile.PressureDifference / 10, 10, 100)));
                 }
+                if (_spaceWindSoundCooldown == 0 && !string.IsNullOrEmpty(WaterMoveSound) && isWaterPresent && !isWaterTooMuch)
+                {
+                     var coordinates = _mapSystem.ToCenterCoordinates(tile.GridIndex, tile.GridIndices);
+                    _audio.PlayPvs(WaterMoveSound, coordinates, AudioParams.Default.WithVariation(0.125f).WithVolume(MathHelper.Clamp(tile.PressureDifference / 10, 10, 100)));
+                }
             }
 
 

Content.Server/Atmos/EntitySystems/FlammableSystem.cs

@@ -28,6 +28,10 @@
 using Robust.Shared.Physics.Events;
 using Robust.Shared.Physics.Systems;
 using Robust.Shared.Random;
+using Content.Shared.Hands;
+using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
+using Content.Server.Chemistry.EntitySystems;
 
 namespace Content.Server.Atmos.EntitySystems
 {
@@ -83,6 +87,8 @@ public override void Initialize()
             SubscribeLocalEvent<IgniteOnHeatDamageComponent, DamageChangedEvent>(OnDamageChanged);
         }
 
+
+
         private void OnMeleeHit(EntityUid uid, IgniteOnMeleeHitComponent component, MeleeHitEvent args)
         {
             foreach (var entity in args.HitEntities)
@@ -96,6 +102,7 @@ private void OnMeleeHit(EntityUid uid, IgniteOnMeleeHitComponent component, Mele
             }
         }
 
+
         private void OnIgniteLand(EntityUid uid, IgniteOnCollideComponent component, ref LandEvent args)
         {
             RemCompDeferred<IgniteOnCollideComponent>(uid);
@@ -454,6 +461,31 @@ public override void Update(float frameTime)
                     Extinguish(uid, flammable);
                 }
             }
+
+            var playerQuery = EntityQueryEnumerator<HandsComponent>();
+        while (playerQuery.MoveNext(out var playerUid, out var handsComponent))
+       {
+           if (!HasComp<JellidComponent>(playerUid))
+              {
+                  continue;
+              }
+
+           if (handsComponent.ActiveHand?.HeldEntity is not EntityUid heldItem)
+               {
+                   continue;
+               }
+
+           if (!TryComp<FlammableComponent>(heldItem, out var flammable))
+              {
+            continue;
+              }
+
+        AdjustFireStacks(heldItem, flammable.FireStacks, flammable);
+        if (flammable.FireStacks >= 0)
+        {
+            Ignite(heldItem, heldItem, flammable, playerUid);
+        }
+      }
         }
     }
 }