Cherrypicks 5 (#399)

* Give moldy food the "Trash" tag (#29380)

Make moldy food items have the "Trash" tag, so they can be collected.

* Add "Structure" tag to switches, buttons, and levers (#29378)
shit
Co-authored-by: Eoin Mcloughlin <helloworld@eoinrul.es>

* Revamped Meteor Swarm (#28974)

* meteor code and balanced values

* Meteor Swarms

* Update meteors.yml

* Update meteors.yml

* HOO! (fix overkill bug and buff space dust)

* undo BloodstreamComponent.cs changes

* DamageDistribution -> DamageTypes

* part 2.

* meteor fixes

* improve meteor spawning (#29057)

* Decrease meteor frequency (#29194)

* Make Projectiles Only Hit a Variety of Station Objects Unless Clicked on (#28571)

* Revert "Make Projectiles Only Hit a Variety of Station Objects Unless Clicked on (#28571)"

This reverts commit 4f934f02f17ce55cabc03b965eb1df7738d63148.

* Makes machine parts stackable, removes unused field in stack prototypes (#28434)

* Makes machine parts stacks, removes unused field in stack prototypes

* forgor

* Fix tests

* Fixes lathe construction. Yes. This sucks but there's no better way that doesnt involve refactoring machine parts completely

* detail

* a

* Add pressure and temperature warning text to firelocks (#28341)

* fix firelocks

* missing nukies can be filled in by ghost roles (#28316)

* Revert "missing nukies can be filled in by ghost roles (#28316)"

This reverts commit 99f13e1e45bc778a4941316fde5d89d7b91337ce.

* welding gas mask (#27108)

* welding gas mask

* eek

* Canes + Cane Blade for Syndicate Librarians (#25873)

* Cane + Cane Blade

* Add - type: ContainerContainer

* Add another - type: ContainerContainer

* Fix and add proper ContainerContainer component

* Add UserInterface component

* Remove Space

* Stat Changes

* review

---------

Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>

* Fix stupid NPC. (#26868)

* init commit

* Review

---------

Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>

* fixes

---------

Co-authored-by: VeritableCalamity <34698192+Veritable-Calamity@users.noreply.github.com>
Co-authored-by: eoineoineoin <github@eoinrul.es>
Co-authored-by: Nemanja <98561806+EmoGarbage404@users.noreply.github.com>
Co-authored-by: Cojoke <83733158+Cojoke-dot@users.noreply.github.com>
Co-authored-by: AJCM-git <60196617+AJCM-git@users.noreply.github.com>
Co-authored-by: ShadowCommander <10494922+ShadowCommander@users.noreply.github.com>
Co-authored-by: deltanedas <39013340+deltanedas@users.noreply.github.com>
Co-authored-by: Ps3Moira <113228053+ps3moira@users.noreply.github.com>
Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>
Co-authored-by: Vigers Ray <60344369+VigersRay@users.noreply.github.com>

Content.Shared/CCVar/CCVars.cs

@@ -121,6 +121,18 @@ namespace Content.Shared.CCVar
         public static readonly CVarDef<float>
             EventsRampingAverageChaos = CVarDef.Create("events.ramping_average_chaos", 6f, CVar.ARCHIVE | CVar.SERVERONLY);
 
+        /// <summary>
+        ///     Minimum time between meteor swarms in minutes.
+        /// </summary>
+        public static readonly CVarDef<float>
+            MeteorSwarmMinTime = CVarDef.Create("events.meteor_swarm_min_time", 12.5f, CVar.ARCHIVE | CVar.SERVERONLY);
+
+        /// <summary>
+        ///     Maximum time between meteor swarms in minutes.
+        /// </summary>
+        public static readonly CVarDef<float>
+            MeteorSwarmMaxTime = CVarDef.Create("events.meteor_swarm_max_time", 17.5f, CVar.ARCHIVE | CVar.SERVERONLY);
+
         /*
          * Game
          */

Content.Shared/Construction/MachinePartSystem.cs

@@ -87,9 +87,9 @@ namespace Content.Shared.Construction
             foreach (var (stackId, amount) in comp.MaterialIdRequirements)
             {
                 var stackProto = _prototype.Index<StackPrototype>(stackId);
+                var defaultProto = _prototype.Index(stackProto.Spawn);
 
-                if (_prototype.TryIndex(stackProto.Spawn, out var defaultProto) &&
-                    defaultProto.TryGetComponent<PhysicalCompositionComponent>(out var physComp))
+                if (defaultProto.TryGetComponent<PhysicalCompositionComponent>(out var physComp))
                 {
                     foreach (var (mat, matAmount) in physComp.MaterialComposition)
                     {

Content.Shared/Doors/Components/FirelockComponent.cs

@@ -1,4 +1,4 @@
-using Content.Shared.Doors.Components;
+using Robust.Shared.GameStates;
 
 namespace Content.Shared.Doors.Components
 {
@@ -7,9 +7,11 @@ namespace Content.Shared.Doors.Components
     /// auto-closing on depressurization, air/fire alarm interactions, and preventing normal door functions when
     /// retaining pressure..
     /// </summary>
-    [RegisterComponent]
+    [RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
     public sealed partial class FirelockComponent : Component
     {
+        #region Settings
+
         /// <summary>
         /// Pry time modifier to be used when the firelock is currently closed due to fire or pressure.
         /// </summary>
@@ -17,8 +19,6 @@ namespace Content.Shared.Doors.Components
         [DataField("lockedPryTimeModifier"), ViewVariables(VVAccess.ReadWrite)]
         public float LockedPryTimeModifier = 1.5f;
 
-        [DataField("autocloseDelay")] public TimeSpan AutocloseDelay = TimeSpan.FromSeconds(3f);
-
         /// <summary>
         /// Maximum pressure difference before the firelock will refuse to open, in kPa.
         /// </summary>
@@ -39,5 +39,47 @@ namespace Content.Shared.Doors.Components
         /// </summary>
         [DataField("alarmAutoClose"), ViewVariables(VVAccess.ReadWrite)]
         public bool AlarmAutoClose = true;
+
+        /// <summary>
+        /// The cooldown duration before a firelock can automatically close due to a hazardous environment after it has
+        /// been pried open. Measured in seconds.
+        /// </summary>
+        [DataField]
+        public TimeSpan EmergencyCloseCooldownDuration = TimeSpan.FromSeconds(2);
+
+        #endregion
+
+        #region Set by system
+
+        /// <summary>
+        /// When the firelock will be allowed to automatically close again due to a hazardous environment.
+        /// </summary>
+        [DataField]
+        public TimeSpan? EmergencyCloseCooldown;
+
+        /// <summary>
+        /// Whether the firelock can open, or is locked due to its environment.
+        /// </summary>
+        public bool IsLocked => Pressure || Temperature;
+
+        /// <summary>
+        /// Whether the firelock is holding back a hazardous pressure.
+        /// </summary>
+        [DataField, AutoNetworkedField]
+        public bool Pressure;
+
+        /// <summary>
+        /// Whether the firelock is holding back extreme temperatures.
+        /// </summary>
+        [DataField, AutoNetworkedField]
+        public bool Temperature;
+
+        /// <summary>
+        /// Whether the airlock is powered.
+        /// </summary>
+        [DataField, AutoNetworkedField]
+        public bool Powered;
+
+        #endregion
     }
 }

Content.Shared/Doors/Systems/SharedFirelockSystem.cs

@@ -0,0 +1,124 @@
+using Content.Shared.Access.Systems;
+using Content.Shared.Doors.Components;
+using Content.Shared.Examine;
+using Content.Shared.Popups;
+using Content.Shared.Prying.Components;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Doors.Systems;
+
+public abstract class SharedFirelockSystem : EntitySystem
+{
+    [Dependency] private readonly AccessReaderSystem _accessReaderSystem = default!;
+    [Dependency] private readonly SharedPopupSystem _popupSystem = default!;
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly SharedDoorSystem _doorSystem = default!;
+    [Dependency] private readonly IGameTiming _gameTiming = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        // Access/Prying
+        SubscribeLocalEvent<FirelockComponent, BeforeDoorOpenedEvent>(OnBeforeDoorOpened);
+        SubscribeLocalEvent<FirelockComponent, GetPryTimeModifierEvent>(OnDoorGetPryTimeModifier);
+        SubscribeLocalEvent<FirelockComponent, PriedEvent>(OnAfterPried);
+
+        // Visuals
+        SubscribeLocalEvent<FirelockComponent, MapInitEvent>(UpdateVisuals);
+        SubscribeLocalEvent<FirelockComponent, ComponentStartup>(UpdateVisuals);
+
+        SubscribeLocalEvent<FirelockComponent, ExaminedEvent>(OnExamined);
+    }
+
+    public bool EmergencyPressureStop(EntityUid uid, FirelockComponent? firelock = null, DoorComponent? door = null)
+    {
+        if (!Resolve(uid, ref firelock, ref door))
+            return false;
+
+        if (door.State != DoorState.Open
+            || firelock.EmergencyCloseCooldown != null
+            && _gameTiming.CurTime < firelock.EmergencyCloseCooldown)
+            return false;
+
+        if (!_doorSystem.TryClose(uid, door))
+            return false;
+
+        return _doorSystem.OnPartialClose(uid, door);
+    }
+
+    #region Access/Prying
+
+    private void OnBeforeDoorOpened(EntityUid uid, FirelockComponent component, BeforeDoorOpenedEvent args)
+    {
+        // Give the Door remote the ability to force a firelock open even if it is holding back dangerous gas
+        var overrideAccess = (args.User != null) && _accessReaderSystem.IsAllowed(args.User.Value, uid);
+
+        if (!component.Powered || (!overrideAccess && component.IsLocked))
+            args.Cancel();
+    }
+
+    private void OnDoorGetPryTimeModifier(EntityUid uid, FirelockComponent component, ref GetPryTimeModifierEvent args)
+    {
+        if (component.Temperature)
+        {
+            _popupSystem.PopupClient(Loc.GetString("firelock-component-is-holding-fire-message"),
+                uid, args.User, PopupType.MediumCaution);
+        }
+        else if (component.Pressure)
+        {
+            _popupSystem.PopupClient(Loc.GetString("firelock-component-is-holding-pressure-message"),
+                uid, args.User, PopupType.MediumCaution);
+        }
+
+        if (component.IsLocked)
+            args.PryTimeModifier *= component.LockedPryTimeModifier;
+    }
+
+    private void OnAfterPried(EntityUid uid, FirelockComponent component, ref PriedEvent args)
+    {
+        component.EmergencyCloseCooldown = _gameTiming.CurTime + component.EmergencyCloseCooldownDuration;
+    }
+
+    #endregion
+
+    #region Visuals
+
+    private void UpdateVisuals(EntityUid uid, FirelockComponent component, EntityEventArgs args) => UpdateVisuals(uid, component);
+
+    private void UpdateVisuals(EntityUid uid,
+        FirelockComponent? firelock = null,
+        DoorComponent? door = null,
+        AppearanceComponent? appearance = null)
+    {
+        if (!Resolve(uid, ref door, ref appearance, false))
+            return;
+
+        // only bother to check pressure on doors that are some variation of closed.
+        if (door.State != DoorState.Closed
+            && door.State != DoorState.Welded
+            && door.State != DoorState.Denying)
+        {
+            _appearance.SetData(uid, DoorVisuals.ClosedLights, false, appearance);
+            return;
+        }
+
+        if (!Resolve(uid, ref firelock, ref appearance, false))
+            return;
+
+        _appearance.SetData(uid, DoorVisuals.ClosedLights, firelock.IsLocked, appearance);
+    }
+
+    #endregion
+
+    private void OnExamined(Entity<FirelockComponent> ent, ref ExaminedEvent args)
+    {
+        using (args.PushGroup(nameof(FirelockComponent)))
+        {
+            if (ent.Comp.Pressure)
+                args.PushMarkup(Loc.GetString("firelock-component-examine-pressure-warning"));
+            if (ent.Comp.Temperature)
+                args.PushMarkup(Loc.GetString("firelock-component-examine-temperature-warning"));
+        }
+    }
+}

Content.Shared/Materials/MaterialPrototype.cs

@@ -29,7 +29,7 @@ namespace Content.Shared.Materials
         ///     include which stack we should spawn by default.
         /// </summary>
         [DataField]
-        public ProtoId<EntityPrototype>? StackEntity;
+        public EntProtoId? StackEntity;
 
         [DataField]
         public string Name = string.Empty;

Content.Shared/Mobs/Systems/MobThresholdSystem.cs

@@ -212,7 +212,7 @@ public sealed class MobThresholdSystem : EntitySystem
         MobThresholdsComponent? thresholdComponent = null)
     {
         threshold = null;
-        if (!Resolve(target, ref thresholdComponent))
+        if (!Resolve(target, ref thresholdComponent, false))
             return false;
 
         return TryGetThresholdForState(target, MobState.Dead, out threshold, thresholdComponent);

Content.Shared/Stacks/StackPrototype.cs

@@ -4,7 +4,7 @@ using Robust.Shared.Utility;
 
 namespace Content.Shared.Stacks;
 
-[Prototype("stack")]
+[Prototype]
 public sealed partial class StackPrototype : IPrototype
 {
     [ViewVariables]
@@ -15,33 +15,26 @@ public sealed partial class StackPrototype : IPrototype
     ///     Human-readable name for this stack type e.g. "Steel"
     /// </summary>
     /// <remarks>This is a localization string ID.</remarks>
-    [DataField("name")]
+    [DataField]
     public string Name { get; private set; } = string.Empty;
 
     /// <summary>
     ///     An icon that will be used to represent this stack type.
     /// </summary>
-    [DataField("icon")]
+    [DataField]
     public SpriteSpecifier? Icon { get; private set; }
 
     /// <summary>
     ///     The entity id that will be spawned by default from this stack.
     /// </summary>
-    [DataField("spawn", required: true, customTypeSerializer:typeof(PrototypeIdSerializer<EntityPrototype>))]
-    public string Spawn { get; private set; } = string.Empty;
+    [DataField(required: true)]
+    public EntProtoId Spawn { get; private set; } = string.Empty;
 
     /// <summary>
     ///     The maximum amount of things that can be in a stack.
     ///     Can be overriden on <see cref="StackComponent"/>
     ///     if null, simply has unlimited max count.
     /// </summary>
-    [DataField("maxCount")]
+    [DataField]
     public int? MaxCount { get; private set; }
-
-    /// <summary>
-    /// The size of an individual unit of this stack.
-    /// </summary>
-    [DataField("itemSize")]
-    public int? ItemSize;
 }
-