Merge branch 'starlight-dev' into nitriumening

Author: OrangeJuiceGoose

Content.Client/Chemistry/Containers/EntitySystems/SolutionContainerSystem.cs

@@ -2,6 +2,4 @@
 
 namespace Content.Client.Chemistry.Containers.EntitySystems;
 
-public sealed partial class SolutionContainerSystem : SharedSolutionContainerSystem
-{
-}
+public sealed partial class SolutionContainerSystem : SharedSolutionContainerSystem;

Content.Client/Chemistry/EntitySystems/ChemistryGuideDataSystem.cs

@@ -116,9 +116,8 @@ private void OnPrototypesReloaded(PrototypesReloadedEventArgs? ev)
             }
 
 
-            if (extractableComponent.GrindableSolution is { } grindableSolutionId &&
-                entProto.TryGetComponent<SolutionContainerManagerComponent>(out var manager, EntityManager.ComponentFactory) &&
-                _solutionContainer.TryGetSolution(manager, grindableSolutionId, out var grindableSolution))
+            if (extractableComponent.GrindableSolutionName is { } grindableSolutionId &&
+                _solutionContainer.TryGetSolution(entProto, grindableSolutionId, out var grindableSolution))
             {
                 var data = new ReagentEntitySourceData(
                     new() { DefaultGrindCategory },

Content.Client/Chemistry/UI/ChemMasterWindow.xaml.cs

@@ -138,10 +138,10 @@ private List<ReagentButton> CreateReagentTransferButtons(ReagentId reagent, bool
                 ("10", ChemMasterReagentAmount.U10, StyleClass.ButtonOpenBoth),
                 ("15", ChemMasterReagentAmount.U15, StyleClass.ButtonOpenBoth),
                 ("20", ChemMasterReagentAmount.U20, StyleClass.ButtonOpenBoth),
-                ("25", ChemMasterReagentAmount.U25, StyleClass.ButtonOpenBoth),
                 ("30", ChemMasterReagentAmount.U30, StyleClass.ButtonOpenBoth),
-                ("50", ChemMasterReagentAmount.U50, StyleClass.ButtonOpenBoth),
-                ("100", ChemMasterReagentAmount.U100, StyleClass.ButtonOpenBoth),
+                ("40", ChemMasterReagentAmount.U40, StyleClass.ButtonOpenBoth),
+                ("60", ChemMasterReagentAmount.U60, StyleClass.ButtonOpenBoth),
+                ("120", ChemMasterReagentAmount.U120, StyleClass.ButtonOpenBoth),
                 (Loc.GetString("chem-master-window-buffer-all-amount"), ChemMasterReagentAmount.All, StyleClass.ButtonOpenLeft),
             };
 

Content.Client/Chemistry/UI/ReagentDispenserWindow.xaml

@@ -15,7 +15,7 @@
                 Columns="3"
                 HorizontalAlignment="Center"
                 Margin="5"
-                ButtonList="1,5,10,15,20,25,30,50,100"
+                ButtonList="1,5,10,15,20,30,40,60,120"
                 RadioGroup="True">
             </ui:ButtonGrid>
             <!-- Starlight-start -->

Content.Client/Players/PlayTimeTracking/JobRequirementsManager.cs

@@ -60,7 +60,7 @@ public void Initialize()
 
         // NullLink start
         _net.RegisterNetMessage<MsgUpdatePlayerPlayTime>(Update);
-        _achievements.AchievementsUpdated += OnAchievementsUpdated;
+        _achievements.AchievementUnlocked += OnAchievementsUnlocked;
         _cfg.OnValueChanged(NullLinkCCVars.Project, OnProjectChanged, true);
         _cfg.OnValueChanged(NullLinkCCVars.Server, OnServerChanged, true);
         // NullLink end
@@ -121,7 +121,7 @@ private void MergePlayTime()
         Updated?.Invoke();
     }
 
-    private void OnAchievementsUpdated()
+    private void OnAchievementsUnlocked(string achievement)
         =>  Updated?.Invoke();
     // Nulllink end
 

Content.Client/_Starlight/Kitchen/EntitySystems/SharpSystem.cs

@@ -14,7 +14,7 @@
                                    Columns="3"
                                    HorizontalAlignment="Center"
                                    Margin="5 4"
-                                   ButtonList="1,5,10,15,20,25,30,50,100"
+                                   ButtonList="1,5,10,15,20,30,40,60,120"
                                    RadioGroup="True" />
 
                 <Control VerticalExpand="True" />

Content.Client/_Starlight/Plumbing/UI/PlumbingSmartDispenserWindow.xaml

@@ -4,8 +4,6 @@
 using Content.IntegrationTests.Fixtures;
 using Content.Server.Cargo.Components;
 using Content.Server.Cargo.Systems;
-using Content.Server.Nutrition.Components;
-using Content.Server.Nutrition.EntitySystems;
 using Content.Shared.Cargo.Components;
 using Content.Shared.Cargo.Prototypes;
 using Content.Shared.Mobs.Components;
@@ -15,6 +13,8 @@
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
+using Content.Shared.Storage;
+using Content.Shared.Tools.Components;
 
 namespace Content.IntegrationTests.Tests;
 
@@ -153,7 +153,6 @@ public async Task NoSliceableBountyArbitrageTest()
         var componentFactory = server.ResolveDependency<IComponentFactory>();
         var whitelist = entManager.System<EntityWhitelistSystem>();
         var cargo = entManager.System<CargoSystem>();
-        var sliceableSys = entManager.System<SliceableFoodSystem>();
 
         var bounties = protoManager.EnumeratePrototypes<CargoBountyPrototype>().ToList();
 
@@ -166,14 +165,14 @@ await server.WaitAssertion(() =>
             var sliceableEntityProtos = protoManager.EnumeratePrototypes<EntityPrototype>()
                 .Where(p => !p.Abstract)
                 .Where(p => !pair.IsTestPrototype(p))
-                .Where(p => p.TryGetComponent<SliceableFoodComponent>(out _, componentFactory))
+                .Where(p => p.TryGetComponent<ToolRefinableComponent>(out _, componentFactory))
                 .Select(p => p.ID)
                 .ToList();
 
             foreach (var proto in sliceableEntityProtos)
             {
                 var ent = entManager.SpawnEntity(proto, coord);
-                var sliceable = entManager.GetComponent<SliceableFoodComponent>(ent);
+                var sliceable = entManager.GetComponent<ToolRefinableComponent>(ent);
 
                 // Check each bounty
                 foreach (var bounty in bounties)
@@ -186,19 +185,32 @@ await server.WaitAssertion(() =>
                             continue;
 
                         // Spawn a slice
-                        var slice = entManager.SpawnEntity(sliceable.Slice, coord);
 
-                        // See if the slice also counts for this bounty entry
-                        if (!cargo.IsValidBountyEntry(slice, entry))
+                        var sliceCountByProtoId = EntitySpawnCollection.GetSpawns(sliceable.RefineResult)
+                                                                    .GroupBy(x => x)
+                                                                    .ToDictionary(x => x.Key, x => x.Count());
+
+                        foreach (var (sliceProtoId, sliceCount) in sliceCountByProtoId)
                         {
-                            entManager.DeleteEntity(slice);
-                            continue;
-                        }
+                            var slice = entManager.SpawnEntity(sliceProtoId, coord);
 
-                        entManager.DeleteEntity(slice);
+                            // See if the slice also counts for this bounty entry
+                            if (!cargo.IsValidBountyEntry(slice, entry))
+                            {
+                                entManager.DeleteEntity(slice);
+                                continue;
+                            }
 
-                        // If for some reason it can only make one slice, that's okay, I guess
-                        Assert.That(sliceable.TotalCount, Is.EqualTo(1), $"{proto} counts as part of cargo bounty {bounty.ID} and slices into {sliceable.TotalCount} slices which count for the same bounty!");
+                            entManager.DeleteEntity(slice);
+
+                            // If for some reason it can only make one slice, that's okay, I guess
+                            Assert.That(
+                                sliceCount,
+                                Is.EqualTo(1),
+                                $"{proto} counts as part of cargo bounty {bounty.ID} "
+                                + $"and slices into {sliceCount} slices which count for the same bounty!"
+                            );
+                        }
                     }
                 }
 

Content.IntegrationTests/Tests/CargoTest.cs

@@ -20,19 +20,19 @@ public sealed class DrainTest : InteractionTest
 
     [TestPrototypes]
     private static readonly string Prototypes = @$"
-- type: entity
-  parent: Puddle
-  id: PuddleBloodTest
-  suffix: Blood (30u)
-  components:
-  - type: SolutionContainerManager
-    solutions:
-      puddle:
-        maxVol: 1000
-        reagents:
-        - ReagentId: {BloodReagent}
-          Quantity: {PuddleVolume}
-";
+    -   type: entity
+        parent: Puddle
+        id: PuddleBloodTest
+        suffix: Blood
+        components:
+        -   type: Solution
+            id: puddle
+            solution:
+                maxVol: 1000
+                reagents:
+                -   ReagentId: {BloodReagent}
+                    Quantity: {PuddleVolume}
+    ";
 
 
     /// <summary>

Content.IntegrationTests/Tests/Chemistry/DrainTest.cs

@@ -0,0 +1,48 @@
+using Content.IntegrationTests.Fixtures;
+using Content.IntegrationTests.Fixtures.Attributes;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Chemistry;
+
+[TestFixture]
+[TestOf(typeof(SolutionRegenerationSystem))]
+[TestOf(typeof(SolutionPurgeSystem))]
+public sealed class SolutionPurgeRegenerationTests : GameTest
+{
+    private static readonly EntProtoId AdvancedMop = "AdvMopItem";
+    private static readonly ProtoId<ReagentPrototype> Water = "Water";
+    private static readonly ProtoId<ReagentPrototype> NotWater = "DexalinPlus";
+
+    [SidedDependency(Side.Server)] private readonly SharedSolutionContainerSystem _solutionContainer = default!;
+
+    [Test]
+    public async Task TestMop()
+    {
+        var testMap = await Pair.CreateTestMap();
+
+        EntityUid mop = default!;
+        Entity<SolutionComponent> solution = default!;
+        await Server.WaitPost(() =>
+        {
+            mop = SSpawnAtPosition(AdvancedMop, testMap.GridCoords);
+
+            var generated = SComp<SolutionRegenerationComponent>(mop).Generated;
+            var purge = SComp<SolutionPurgeComponent>(mop);
+            Assume.That(generated.ContainsPrototype(Water));
+            Assume.That(purge.Preserve, Does.Not.Contain(NotWater));
+
+
+            Assert.That(_solutionContainer.TryGetSolution(mop, "absorbed", out var mopSolution, out _));
+            solution = mopSolution!.Value;
+            Assert.That(_solutionContainer.AddSolution(solution, new Solution(NotWater, 50)), Is.EqualTo(FixedPoint2.New(50)));
+        });
+
+        await PoolManager.WaitUntil(Server, () => !solution.Comp.Solution.ContainsPrototype(NotWater));
+        await PoolManager.WaitUntil(Server, () => solution.Comp.Solution.Volume == solution.Comp.Solution.MaxVolume);
+    }
+}