Recyclable clothing arbitrage test

.github/workflows/build-test-debug.yml

@@ -50,11 +50,11 @@ jobs:
     - name: Run Content.Tests
       run: dotnet test --no-build --configuration DebugOpt Content.Tests/Content.Tests.csproj -- NUnit.ConsoleOut=0
 
-    # - name: Run Content.IntegrationTests
-    #   shell: pwsh
-    #   run: |
-    #     $env:DOTNET_gcServer=1
-    #     dotnet test --no-build --configuration DebugOpt Content.IntegrationTests/Content.IntegrationTests.csproj --filter FullyQualifiedName!~ShipyardTest -- NUnit.ConsoleOut=0 NUnit.MapWarningTo=Failed
+    - name: Run Content.IntegrationTests
+      shell: pwsh
+      run: |
+        $env:DOTNET_gcServer=1
+        dotnet test --no-build --configuration DebugOpt Content.IntegrationTests/Content.IntegrationTests.csproj --filter FullyQualifiedName!~ShipyardTest -- NUnit.ConsoleOut=0 NUnit.MapWarningTo=Failed
   ci-success:
     name: Build & Test Debug
     needs:

Content.Client/Entry/EntryPoint.cs

@@ -35,6 +35,7 @@
 using Robust.Shared.Prototypes;
 using Robust.Shared.Replays;
 using Robust.Shared.Timing;
+using Content.Client._NF.Emp.Overlays; // Frontier
 
 namespace Content.Client.Entry
 {
@@ -154,6 +155,7 @@ public override void PostInit()
 
             _overlayManager.AddOverlay(new SingularityOverlay());
             _overlayManager.AddOverlay(new RadiationPulseOverlay());
+            _overlayManager.AddOverlay(new EmpBlastOverlay()); // Frontier
             _chatManager.Initialize();
             _clientPreferencesManager.Initialize();
             _euiManager.Initialize();

Content.Client/_NF/Emp/Overlays/EmpBlastOverlay.cs

@@ -0,0 +1,145 @@
+using System.Numerics;
+using Content.Shared._NF.Emp.Components;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Graphics;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Client._NF.Emp.Overlays
+{
+    public sealed class EmpBlastOverlay : Overlay
+    {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly IGameTiming _gameTiming = default!;
+        private TransformSystem? _transform;
+
+        private const float PvsDist = 25.0f;
+
+        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+        public override bool RequestScreenTexture => true;
+
+        private readonly ShaderInstance _baseShader;
+        private readonly Dictionary<EntityUid, (ShaderInstance shd, EmpShaderInstance instance)> _blasts = new();
+
+        public EmpBlastOverlay()
+        {
+            IoCManager.InjectDependencies(this);
+            _baseShader = _prototypeManager.Index<ShaderPrototype>("Emp").Instance().Duplicate();
+        }
+
+        protected override bool BeforeDraw(in OverlayDrawArgs args)
+        {
+            EmpQuery(args.Viewport.Eye);
+            return _blasts.Count > 0;
+        }
+
+        protected override void Draw(in OverlayDrawArgs args)
+        {
+            if (ScreenTexture == null)
+                return;
+
+            var worldHandle = args.WorldHandle;
+            var viewport = args.Viewport;
+
+            foreach ((var shd, var instance) in _blasts.Values)
+            {
+                if (instance.CurrentMapCoords.MapId != args.MapId)
+                    continue;
+
+                // To be clear, this needs to use "inside-viewport" pixels.
+                // In other words, specifically NOT IViewportControl.WorldToScreen (which uses outer coordinates).
+                var tempCoords = viewport.WorldToLocal(instance.CurrentMapCoords.Position);
+                tempCoords.Y = viewport.Size.Y - tempCoords.Y;
+                shd?.SetParameter("renderScale", viewport.RenderScale);
+                shd?.SetParameter("positionInput", tempCoords);
+                shd?.SetParameter("range", instance.Range);
+                var life = (_gameTiming.RealTime - instance.Start).TotalSeconds / instance.Duration;
+                shd?.SetParameter("life", (float)life);
+
+                // There's probably a very good reason not to do this.
+                // Oh well!
+                shd?.SetParameter("SCREEN_TEXTURE", viewport.RenderTarget.Texture);
+
+                worldHandle.UseShader(shd);
+                worldHandle.DrawRect(Box2.CenteredAround(instance.CurrentMapCoords.Position, new Vector2(instance.Range, instance.Range) * 2f), Color.White);
+            }
+
+            worldHandle.UseShader(null);
+        }
+
+        //Queries all blasts on the map and either adds or removes them from the list of rendered blasts based on whether they should be drawn (in range? on the same z-level/map? blast entity still exists?)
+        private void EmpQuery(IEye? currentEye)
+        {
+            _transform ??= _entityManager.System<TransformSystem>();
+
+            if (currentEye == null)
+            {
+                _blasts.Clear();
+                return;
+            }
+
+            var currentEyeLoc = currentEye.Position;
+
+            var blasts = _entityManager.EntityQueryEnumerator<EmpBlastComponent>();
+            //Add all blasts that are not added yet but qualify
+            while (blasts.MoveNext(out var blastEntity, out var blast))
+            {
+                if (!_blasts.ContainsKey(blastEntity) && BlastQualifies(blastEntity, currentEyeLoc, blast))
+                {
+                    _blasts.Add(
+                            blastEntity,
+                            (
+                                _baseShader.Duplicate(),
+                                new EmpShaderInstance(
+                                    _transform.GetMapCoordinates(blastEntity),
+                                    blast.VisualRange,
+                                    blast.StartTime,
+                                    blast.VisualDuration
+                                )
+                            )
+                    );
+                }
+            }
+
+            var activeShaderIds = _blasts.Keys;
+            foreach (var blastEntity in activeShaderIds) //Remove all blasts that are added and no longer qualify
+            {
+                if (_entityManager.EntityExists(blastEntity) &&
+                    _entityManager.TryGetComponent(blastEntity, out EmpBlastComponent? blast) &&
+                    BlastQualifies(blastEntity, currentEyeLoc, blast))
+                {
+                    var shaderInstance = _blasts[blastEntity];
+                    shaderInstance.instance.CurrentMapCoords = _transform.GetMapCoordinates(blastEntity);
+                    shaderInstance.instance.Range = blast.VisualRange;
+                }
+                else
+                {
+                    _blasts[blastEntity].shd.Dispose();
+                    _blasts.Remove(blastEntity);
+                }
+            }
+
+        }
+
+        private bool BlastQualifies(EntityUid blastEntity, MapCoordinates currentEyeLoc, EmpBlastComponent blast)
+        {
+            var transformComponent = _entityManager.GetComponent<TransformComponent>(blastEntity);
+            var transformSystem = _entityManager.System<SharedTransformSystem>();
+            return transformComponent.MapID == currentEyeLoc.MapId
+                && transformSystem.InRange(transformComponent.Coordinates, transformSystem.ToCoordinates(transformComponent.ParentUid, currentEyeLoc), PvsDist + blast.VisualRange);
+        }
+
+        private sealed record EmpShaderInstance(MapCoordinates CurrentMapCoords, float Range, TimeSpan Start, float Duration)
+        {
+            public MapCoordinates CurrentMapCoords = CurrentMapCoords;
+            public float Range = Range;
+            public TimeSpan Start = Start;
+            public float Duration = Duration;
+        };
+    }
+}
+

Content.IntegrationTests/Tests/EntityTest.cs

@@ -102,10 +102,21 @@ await server.WaitPost(() =>
                     .Where(p => !p.Components.ContainsKey("MapGrid")) // This will smash stuff otherwise.
                     .Select(p => p.ID)
                     .ToList();
+                bool anyException = false;
                 foreach (var protoId in protoIds)
                 {
-                    entityMan.SpawnEntity(protoId, map.GridCoords);
+                    Logger.Info($"Spawning proto {protoId}");
+                    try
+                    {
+                        entityMan.SpawnEntity(protoId, map.GridCoords);
+                    }
+                    catch (Exception e)
+                    {
+                        Logger.Info($"Exception while spawning proto {protoId}: \"{e.Message}\" {e.StackTrace}");
+                        anyException = true;
+                    }
                 }
+                Assert.That(anyException, Is.EqualTo(false), "One or more exceptions occurred during entity spawn.");
             });
             await server.WaitRunTicks(15);
             await server.WaitPost(() =>
@@ -120,13 +131,26 @@ await server.WaitPost(() =>
                     }
                 }
 
+                bool anyException = false;
                 var entityMetas = Query<MetaDataComponent>(entityMan).ToList();
                 foreach (var (uid, meta) in entityMetas)
                 {
-                    if (!meta.EntityDeleted)
-                        entityMan.DeleteEntity(uid);
+                    Logger.Info($"Deleting entity {meta.EntityPrototype?.ID ?? "null"} ({uid})");
+                    try
+                    {
+                        if (!meta.EntityDeleted)
+                            entityMan.DeleteEntity(uid);
+                    }
+                    catch (Exception e)
+                    {
+                        Logger.Info($"Exception while deleting entity {meta.EntityPrototype?.ID ?? "null"} ({uid}): \"{e.Message}\" {e.StackTrace}");
+                        anyException = true;
+                    }
                 }
 
+                Assert.That(anyException, Is.EqualTo(false), "One or more exceptions occurred during entity deletion.");
+
+
                 Assert.That(entityMan.EntityCount, Is.Zero);
             });
 

Content.Server/Emp/EmpSystem.cs

@@ -10,15 +10,21 @@
 using Content.Shared.Tiles; // Frontier
 using Robust.Server.GameObjects;
 using Robust.Shared.Map;
+using Content.Shared._NF.Emp.Components; // Frontier
+using Robust.Server.GameStates; // Frontier: EMP Blast PVS
+using Robust.Shared.Configuration; // Frontier: EMP Blast PVS
+using Robust.Shared; // Frontier: EMP Blast PVS
 
 namespace Content.Server.Emp;
 
 public sealed class EmpSystem : SharedEmpSystem
 {
     [Dependency] private readonly EntityLookupSystem _lookup = default!;
     [Dependency] private readonly TransformSystem _transform = default!;
+    [Dependency] private readonly PvsOverrideSystem _pvs = default!; // Frontier: EMP Blast PVS
+    [Dependency] private readonly IConfigurationManager _cfg = default!; // Frontier: EMP Blast PVS
 
-    public const string EmpPulseEffectPrototype = "EffectEmpPulse";
+    public const string EmpPulseEffectPrototype = "EffectEmpBlast"; // Frontier: EffectEmpPulse
 
     public override void Initialize()
     {
@@ -54,7 +60,15 @@ public void EmpPulse(MapCoordinates coordinates, float range, float energyConsum
 
             TryEmpEffects(uid, energyConsumption, duration);
         }
-        Spawn(EmpPulseEffectPrototype, coordinates);
+
+        var empBlast = Spawn(EmpPulseEffectPrototype, coordinates); // Frontier: Added visual effect
+        EnsureComp<EmpBlastComponent>(empBlast, out var empBlastComp); // Frontier
+        empBlastComp.VisualRange = range; // Frontier
+
+        if (range > _cfg.GetCVar(CVars.NetMaxUpdateRange)) // Frontier
+            _pvs.AddGlobalOverride(empBlast); // Frontier
+
+        Dirty(empBlast, empBlastComp); // Frontier
     }
 
     /// <summary>

Content.Server/Holiday/HolidayPrototype.cs

@@ -41,6 +41,9 @@ public sealed partial class HolidayPrototype : IPrototype
         [DataField("celebrate")]
         private IHolidayCelebrate? _celebrate = null;
 
+        [DataField("entityReplacements")] // Frontier
+        public Dictionary<EntProtoId, EntProtoId>? EntityReplacements = null; // Frontier
+
         public bool ShouldCelebrate(DateTime date)
         {
             return _shouldCelebrate.ShouldCelebrate(date, this);

Content.Server/Holiday/HolidaySystem.cs

@@ -4,6 +4,7 @@
 using Content.Shared.CCVar;
 using Content.Shared.Holiday;
 using Robust.Shared.Configuration;
+using Robust.Shared.Map.Events;
 using Robust.Shared.Prototypes;
 
 namespace Content.Server.Holiday
@@ -26,6 +27,7 @@ public override void Initialize()
             Subs.CVar(_configManager, CCVars.HolidaysEnabled, OnHolidaysEnableChange);
             SubscribeLocalEvent<GameRunLevelChangedEvent>(OnRunLevelChanged);
             SubscribeLocalEvent<HolidayVisualsComponent, ComponentInit>(OnVisualsInit);
+            SubscribeLocalEvent<BeforeEntityReadEvent>(OnBeforeRead);
         }
 
         public void RefreshCurrentHolidays()
@@ -115,6 +117,22 @@ private void OnVisualsInit(Entity<HolidayVisualsComponent> ent, ref ComponentIni
                 break;
             }
         }
+
+        // Frontier: holiday-themed entity replacement
+        private void OnBeforeRead(BeforeEntityReadEvent ev)
+        {
+            foreach (var holiday in _currentHolidays)
+            {
+                if (holiday.EntityReplacements is { } replacements)
+                {
+                    foreach (var (original, replacement) in replacements)
+                    {
+                        ev.RenamedPrototypes.TryAdd(original, replacement);
+                    }
+                }
+            }
+        }
+        // End Frontier
     }
 
     /// <summary>

Content.Server/_NF/Bank/BankSystem.cs

@@ -208,11 +208,11 @@ public bool TryBankDeposit(ICommonSession session, PlayerPreferences prefs, Huma
     }
 
     /// <summary>
-    /// Attempts to add money to a character's bank account. This should always be used instead of attempting to modify the bankaccountcomponent directly
+    /// Retrieves a character's balance via its in-game entity, if it has one.
     /// </summary>
     /// <param name="ent">The UID that the bank account is connected to, typically the player controlled mob</param>
-    /// <param name="balance">The amount of spesos to add into the bank account</param>
-    /// <returns>true if the transaction was successful, false if it was not</returns>
+    /// <param name="balance">When successful, contains the account balance in spesos. Otherwise, set to 0.</param>
+    /// <returns>true if the account was successfully queried.</returns>
     public bool TryGetBalance(EntityUid ent, out int balance)
     {
         if (!_playerManager.TryGetSessionByEntity(ent, out var session) ||
@@ -234,6 +234,32 @@ public bool TryGetBalance(EntityUid ent, out int balance)
         return true;
     }
 
+    /// <summary>
+    /// Retrieves a character's balance via a player's session.
+    /// </summary>
+    /// <param name="session">The session of the player character to query.</param>
+    /// <param name="balance">When successful, contains the account balance in spesos. Otherwise, set to 0.</param>
+    /// <returns>true if the account was successfully queried.</returns>
+    public bool TryGetBalance(ICommonSession session, out int balance)
+    {
+        if (!_prefsManager.TryGetCachedPreferences(session.UserId, out var prefs))
+        {
+            _log.Info($"{session.UserId} has no cached prefs");
+            balance = 0;
+            return false;
+        }
+
+        if (prefs.SelectedCharacter is not HumanoidCharacterProfile profile)
+        {
+            _log.Info($"{session.UserId} has the wrong prefs type");
+            balance = 0;
+            return false;
+        }
+
+        balance = profile.BankBalance;
+        return true;
+    }
+
     /// <summary>
     /// Update the bank balance to the character's current account balance.
     /// </summary>

Content.Server/_NF/Construction/ConstructionSystem.Machine.Upgrades.cs

@@ -109,7 +109,7 @@ public Dictionary<string, float> GetPartsRatings(List<MachinePartState> partStat
                 amount += state.Quantity();
                 sumRating += state.Part.Rating * state.Quantity();
             }
-            var rating = amount != 0 ? sumRating / amount : 0;
+            var rating = amount != 0 ? sumRating / amount : 1.0f;
             output.Add(type.ID, rating);
         }