Resolved merge conflicts

Content.IntegrationTests/Tests/Fluids/FluidSpillTest.cs

@@ -73,7 +73,7 @@ await server.WaitPost(() =>
         await server.WaitAssertion(() =>
         {
             var grid = entityManager.GetComponent<MapGridComponent>(gridId);
-            var solution = new Solution("Blood", FixedPoint2.New(100));
+            var solution = new Solution("Wine", FixedPoint2.New(100)); // Frontier - Blood to wine so test pass
             var tileRef = grid.GetTileRef(puddleOrigin);
 #pragma warning disable NUnit2045 // Interdependent tests
             Assert.That(puddleSystem.TrySpillAt(tileRef, solution, out _), Is.True);

Content.Server/Explosion/Components/ExplosiveComponent.cs

@@ -81,6 +81,13 @@ public sealed partial class ExplosiveComponent : Component
     [DataField("deleteAfterExplosion")]
     public bool? DeleteAfterExplosion;
 
+    /// <summary>
+    /// Whether to not set <see cref="Exploded"/> to true, allowing it to explode multiple times.
+    /// This should never be used if it is damageable.
+    /// </summary>
+    [DataField]
+    public bool Repeatable;
+
     /// <summary>
     ///     Avoid somehow double-triggering this explosion (e.g. by damaging this entity from its own explosion.
     /// </summary>

Content.Server/Explosion/Components/RepeatingTriggerComponent.cs

@@ -0,0 +1,25 @@
+using Content.Server.Explosion.EntitySystems;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Server.Explosion.Components;
+
+/// <summary>
+/// Constantly triggers after being added to an entity.
+/// </summary>
+[RegisterComponent, Access(typeof(TriggerSystem))]
+[AutoGenerateComponentPause]
+public sealed partial class RepeatingTriggerComponent : Component
+{
+    /// <summary>
+    /// How long to wait between triggers.
+    /// The first trigger starts this long after the component is added.
+    /// </summary>
+    [DataField]
+    public TimeSpan Delay = TimeSpan.FromSeconds(1);
+
+    /// <summary>
+    /// When the next trigger will be.
+    /// </summary>
+    [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+    public TimeSpan NextTrigger;
+}

Content.Server/Explosion/EntitySystems/ExplosionSystem.cs

@@ -165,7 +165,7 @@ public void TriggerExplosive(EntityUid uid, ExplosiveComponent? explosive = null
         if (explosive.Exploded)
             return;
 
-        explosive.Exploded = true;
+        explosive.Exploded = !explosive.Repeatable;
 
         // Override the explosion intensity if optional arguments were provided.
         if (radius != null)

Content.Server/Explosion/EntitySystems/TriggerSystem.cs

@@ -98,6 +98,7 @@ public override void Initialize()
             SubscribeLocalEvent<TriggerOnStepTriggerComponent, StepTriggeredOffEvent>(OnStepTriggered);
             SubscribeLocalEvent<TriggerOnSlipComponent, SlipEvent>(OnSlipTriggered);
             SubscribeLocalEvent<TriggerWhenEmptyComponent, OnEmptyGunShotEvent>(OnEmptyTriggered);
+            SubscribeLocalEvent<RepeatingTriggerComponent, MapInitEvent>(OnRepeatInit);
 
             SubscribeLocalEvent<SpawnOnTriggerComponent, TriggerEvent>(OnSpawnTrigger);
             SubscribeLocalEvent<DeleteOnTriggerComponent, TriggerEvent>(HandleDeleteTrigger);
@@ -278,6 +279,11 @@ private void OnEmptyTriggered(EntityUid uid, TriggerWhenEmptyComponent component
             Trigger(uid, args.EmptyGun);
         }
 
+        private void OnRepeatInit(Entity<RepeatingTriggerComponent> ent, ref MapInitEvent args)
+        {
+            ent.Comp.NextTrigger = _timing.CurTime + ent.Comp.Delay;
+        }
+
         public bool Trigger(EntityUid trigger, EntityUid? user = null)
         {
             var triggerEvent = new TriggerEvent(trigger, user);
@@ -360,6 +366,7 @@ public override void Update(float frameTime)
             UpdateProximity();
             UpdateTimer(frameTime);
             UpdateTimedCollide(frameTime);
+            UpdateRepeat();
         }
 
         private void UpdateTimer(float frameTime)
@@ -394,5 +401,19 @@ private void UpdateTimer(float frameTime)
                     _appearance.SetData(uid, TriggerVisuals.VisualState, TriggerVisualState.Unprimed, appearance);
             }
         }
+
+        private void UpdateRepeat()
+        {
+            var now = _timing.CurTime;
+            var query = EntityQueryEnumerator<RepeatingTriggerComponent>();
+            while (query.MoveNext(out var uid, out var comp))
+            {
+                if (comp.NextTrigger > now)
+                    continue;
+
+                comp.NextTrigger = now + comp.Delay;
+                Trigger(uid);
+            }
+        }
     }
 }

Content.Server/MassMedia/Systems/NewsSystem.cs

@@ -20,6 +20,7 @@
 using Content.Shared.Popups;
 using Content.Shared.StationRecords;
 using Robust.Shared.Audio.Systems;
+using Content.Shared.GameTicking; // Frontier
 
 namespace Content.Server.MassMedia.Systems;
 
@@ -43,6 +44,8 @@ public override void Initialize()
         // News writer
         // Frontier: News is shared across the sector.  No need to create shuttle-local news caches.
         // SubscribeLocalEvent<NewsWriterComponent, MapInitEvent>(OnMapInit);
+
+        SubscribeLocalEvent<RoundRestartCleanupEvent>(OnRoundRestart);
         // End Frontier
 
         // New writer bui messages
@@ -59,6 +62,14 @@ public override void Initialize()
         SubscribeLocalEvent<NewsReaderCartridgeComponent, CartridgeMessageEvent>(OnReaderUiMessage);
         SubscribeLocalEvent<NewsReaderCartridgeComponent, CartridgeUiReadyEvent>(OnReaderUiReady);
     }
+
+    // Frontier: article lifecycle management
+    private void OnRoundRestart(RoundRestartCleanupEvent ev)
+    {
+        // A new round is starting, clear any articles from the previous round.
+        SectorNewsComponent.Articles.Clear();
+    }
+    // End Frontier
 
     public override void Update(float frameTime)
     {

Content.Shared/Access/Components/IdCardConsoleComponent.cs

@@ -72,7 +72,6 @@ public WriteToTargetIdMessage(string fullName, string jobTitle, List<ProtoId<Acc
         "Maintenance",
         "Medical",
         "Mercenary", // Frontier
-        "Pilot", // Frontier
         //"Quartermaster",
         //"Research",
         //"ResearchDirector",

Content.Shared/Access/Systems/AccessReaderSystem.cs

@@ -164,7 +164,7 @@ public bool IsAllowed(
             return IsAllowedInternal(access, stationKeys, reader);
 
         if (!_containerSystem.TryGetContainer(target, reader.ContainerAccessProvider, out var container))
-            return false;
+            return Paused(target); // when mapping, containers with electronics arent spawned
 
         foreach (var entity in container.ContainedEntities)
         {

Content.Shared/Blocking/BlockingSystem.cs

@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 using Content.Shared.Actions;
 using Content.Shared.Damage;
 using Content.Shared.Examine;
@@ -209,7 +209,7 @@ public bool StartBlocking(EntityUid item, BlockingComponent component, EntityUid
             _fixtureSystem.TryCreateFixture(user,
                 component.Shape,
                 BlockingComponent.BlockFixtureID,
-                hard: true,
+                hard: false, // Frontier - True to false, mobs AI abuse.
                 collisionLayer: (int) CollisionGroup.WallLayer,
                 body: physicsComponent);
         }

Content.Shared/Fluids/SharedPuddleSystem.Evaporation.cs

@@ -8,7 +8,18 @@ public abstract partial class SharedPuddleSystem
     [ValidatePrototypeId<ReagentPrototype>]
     private const string Water = "Water";
 
-    public static readonly string[] EvaporationReagents = [Water];
+    private const string FluorosulfuricAcid = "FluorosulfuricAcid"; // Frontier
+    private const string Vomit = "Vomit"; // Frontier
+    private const string InsectBlood = "InsectBlood"; // Frontier
+    private const string AmmoniaBlood = "AmmoniaBlood"; // Frontier
+    private const string ZombieBlood = "ZombieBlood"; // Frontier
+    private const string Blood = "Blood"; // Frontier
+    private const string Slime = "Slime"; // Frontier
+    private const string CopperBlood = "CopperBlood"; // Frontier
+    private const string Sap = "Sap"; // Frontier
+    private const string JuiceTomato = "JuiceTomato"; // Frontier
+
+    public static readonly string[] EvaporationReagents = [Water, Vomit, InsectBlood, AmmoniaBlood, ZombieBlood, Blood, Slime, CopperBlood, FluorosulfuricAcid, Sap, JuiceTomato]; // Frontier
 
     public bool CanFullyEvaporate(Solution solution)
     {

Content.Shared/Inventory/VirtualItem/SharedVirtualItemSystem.cs

@@ -73,7 +73,6 @@ private void OnBeforeRangedInteract(Entity<VirtualItemComponent> ent, ref Before
     }
 
     #region Hands
-
     /// <summary>
     /// Spawns a virtual item in a empty hand
     /// </summary>
@@ -151,7 +150,7 @@ public void DeleteInHandsMatching(EntityUid user, EntityUid matching)
     /// </summary>
     /// <param name="blockingEnt">The entity we will make a virtual entity copy of</param>
     /// <param name="user">The entity that we want to insert the virtual entity</param>
-    /// <param name="slot">The slot to which we will insert the virtual entity (could be the "shoes" slot, for example)</para
+    /// <param name="slot">The slot to which we will insert the virtual entity (could be the "shoes" slot, for example)</param>
     /// <param name="force">Whether or not to force an equip</param>
     public bool TrySpawnVirtualItemInInventory(EntityUid blockingEnt, EntityUid user, string slot, bool force = false)
     {
@@ -173,6 +172,8 @@ public bool TrySpawnVirtualItemInInventory(EntityUid blockingEnt, EntityUid user
     /// that's done check if the found virtual entity is a copy of our matching entity,
     /// if it is, delete it
     /// </summary>
+    /// <param name="user">The entity that we want to delete the virtual entity from</param>
+    /// <param name="matching">The entity that made the virtual entity</param>
     /// <param name="slotName">Set this param if you have the name of the slot, it avoids unnecessary queries</param>
     /// <param name="user">The entity that we want to delete the virtual entity from</param>
     /// <param name="matching">The entity that made the virtual entity</param>

Content.Shared/Preferences/Loadouts/RoleLoadout.cs

@@ -74,12 +74,20 @@ public void EnsureValid(ICommonSession session, IDependencyCollection collection
             {
                 var loadout = loadouts[i];
 
+                // Old prototype or otherwise invalid.
                 if (!protoManager.TryIndex(loadout.Prototype, out var loadoutProto))
                 {
                     loadouts.RemoveAt(i);
                     continue;
                 }
 
+                // Malicious client maybe, check the group even has it.
+                if (!groupProto.Loadouts.Contains(loadout.Prototype))
+                {
+                    loadouts.RemoveAt(i);
+                    continue;
+                }
+
                 // Validate the loadout can be applied (e.g. points).
                 if (!IsValid(session, loadout.Prototype, collection, out _))
                 {

Content.Shared/Weapons/Ranged/Components/ActionGunComponent.cs

@@ -0,0 +1,37 @@
+using Content.Shared.Actions;
+using Content.Shared.Weapons.Ranged.Systems;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Weapons.Ranged.Components;
+
+/// <summary>
+/// Lets you shoot a gun using an action.
+/// </summary>
+[RegisterComponent, NetworkedComponent, Access(typeof(ActionGunSystem))]
+public sealed partial class ActionGunComponent : Component
+{
+    /// <summary>
+    /// Action to create, must use <see cref="ActionGunShootEvent"/>.
+    /// </summary>
+    [DataField(required: true)]
+    public EntProtoId Action = string.Empty;
+
+    [DataField]
+    public EntityUid? ActionEntity;
+
+    /// <summary>
+    /// Prototype of gun entity to spawn.
+    /// Deleted when this component is removed.
+    /// </summary>
+    [DataField(required: true)]
+    public EntProtoId GunProto = string.Empty;
+
+    [DataField]
+    public EntityUid? Gun;
+}
+
+/// <summary>
+/// Action event for <see cref="ActionGunComponent"/> to shoot at a position.
+/// </summary>
+public sealed partial class ActionGunShootEvent : WorldTargetActionEvent;

Content.Shared/Weapons/Ranged/Events/ShotAttemptedEvent.cs

@@ -1,4 +1,6 @@
 using Content.Shared.Weapons.Ranged.Components;
+
+
 namespace Content.Shared.Weapons.Ranged.Events;
 
 /// <summary>

Content.Shared/Weapons/Ranged/Systems/ActionGunSystem.cs

@@ -0,0 +1,41 @@
+using Content.Shared.Actions;
+using Content.Shared.Weapons.Ranged.Components;
+
+namespace Content.Shared.Weapons.Ranged.Systems;
+
+public sealed class ActionGunSystem : EntitySystem
+{
+    [Dependency] private readonly SharedActionsSystem _actions = default!;
+    [Dependency] private readonly SharedGunSystem _gun = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ActionGunComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<ActionGunComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ActionGunComponent, ActionGunShootEvent>(OnShoot);
+    }
+
+    private void OnMapInit(Entity<ActionGunComponent> ent, ref MapInitEvent args)
+    {
+        if (string.IsNullOrEmpty(ent.Comp.Action))
+            return;
+
+        _actions.AddAction(ent, ref ent.Comp.ActionEntity, ent.Comp.Action);
+        ent.Comp.Gun = Spawn(ent.Comp.GunProto);
+    }
+
+    private void OnShutdown(Entity<ActionGunComponent> ent, ref ComponentShutdown args)
+    {
+        if (ent.Comp.Gun is {} gun)
+            QueueDel(gun);
+    }
+
+    private void OnShoot(Entity<ActionGunComponent> ent, ref ActionGunShootEvent args)
+    {
+        if (TryComp<GunComponent>(ent.Comp.Gun, out var gun))
+            _gun.AttemptShoot(ent, ent.Comp.Gun.Value, gun, args.Target);
+    }
+}
+

Content.Shared/Wieldable/WieldableSystem.cs

@@ -210,8 +210,9 @@ public bool TryWield(EntityUid used, WieldableComponent component, EntityUid use
 
         if (component.WieldSound != null)
             _audioSystem.PlayPredicted(component.WieldSound, used, user);
-
-		var virtuals = new List<EntityUid>();
+
+
+        var virtuals = new List<EntityUid>();
         for (var i = 0; i < component.FreeHandsRequired; i++)
         {
             if (_virtualItemSystem.TrySpawnVirtualItemInHand(used, user, out var virtualItem, true))

Resources/Audio/_NF/Jukebox/attributions.yml

@@ -0,0 +1,4 @@
+- files: ["lateraligator.ogg"]
+  license: "CC-BY-3.0"
+  copyright: "Later Alligator By Silverman Sound Studios. Converted to mono ogg"
+  source: "https://soundcloud.com/silvermansound/later-alligator"