Upstream update

Content.Client/Radio/EntitySystems/RadioDeviceSystem.cs

@@ -0,0 +1,23 @@
+using Content.Client.Radio.Ui;
+using Content.Shared.Radio;
+using Content.Shared.Radio.Components;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.Radio.EntitySystems;
+
+public sealed class RadioDeviceSystem : EntitySystem
+{
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<IntercomComponent, AfterAutoHandleStateEvent>(OnAfterHandleState);
+    }
+
+    private void OnAfterHandleState(Entity<IntercomComponent> ent, ref AfterAutoHandleStateEvent args)
+    {
+        if (_ui.TryGetOpenUi<IntercomBoundUserInterface>(ent.Owner, IntercomUiKey.Key, out var bui))
+            bui.Update(ent);
+    }
+}

Content.Client/Radio/Ui/IntercomBoundUserInterface.cs

@@ -1,6 +1,6 @@
 using Content.Shared.Radio;
+using Content.Shared.Radio.Components;
 using JetBrains.Annotations;
-using Robust.Client.GameObjects;
 
 namespace Content.Client.Radio.Ui;
 
@@ -19,7 +19,9 @@ protected override void Open()
     {
         base.Open();
 
-        _menu = new();
+        var comp = EntMan.GetComponent<IntercomComponent>(Owner);
+
+        _menu = new((Owner, comp));
 
         _menu.OnMicPressed += enabled =>
         {
@@ -46,13 +48,8 @@ protected override void Dispose(bool disposing)
         _menu?.Close();
     }
 
-    protected override void UpdateState(BoundUserInterfaceState state)
+    public void Update(Entity<IntercomComponent> ent)
     {
-        base.UpdateState(state);
-
-        if (state is not IntercomBoundUIState msg)
-            return;
-
-        _menu?.Update(msg);
+        _menu?.Update(ent);
     }
 }

Content.Client/Radio/Ui/IntercomMenu.xaml.cs

@@ -1,8 +1,9 @@
 using Content.Client.UserInterface.Controls;
-using Content.Shared.Radio;
+using Content.Shared.Radio.Components;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Radio.Ui;
 
@@ -17,38 +18,54 @@ public sealed partial class IntercomMenu : FancyWindow
 
     private readonly List<string> _channels = new();
 
-    public IntercomMenu()
+    public IntercomMenu(Entity<IntercomComponent> entity)
     {
         RobustXamlLoader.Load(this);
         IoCManager.InjectDependencies(this);
 
         MicButton.OnPressed += args => OnMicPressed?.Invoke(args.Button.Pressed);
         SpeakerButton.OnPressed += args => OnSpeakerPressed?.Invoke(args.Button.Pressed);
+
+        Update(entity);
     }
 
-    public void Update(IntercomBoundUIState state)
+    public void Update(Entity<IntercomComponent> entity)
     {
-        MicButton.Pressed = state.MicEnabled;
-        SpeakerButton.Pressed = state.SpeakerEnabled;
+        MicButton.Pressed = entity.Comp.MicrophoneEnabled;
+        SpeakerButton.Pressed = entity.Comp.SpeakerEnabled;
+
+        MicButton.Disabled = entity.Comp.SupportedChannels.Count == 0;
+        SpeakerButton.Disabled = entity.Comp.SupportedChannels.Count == 0;
+        ChannelOptions.Disabled = entity.Comp.SupportedChannels.Count == 0;
 
         ChannelOptions.Clear();
         _channels.Clear();
-        for (var i = 0; i < state.AvailableChannels.Count; i++)
+        for (var i = 0; i < entity.Comp.SupportedChannels.Count; i++)
         {
-            var channel = state.AvailableChannels[i];
-            if (!_prototype.TryIndex<RadioChannelPrototype>(channel, out var prototype))
+            var channel = entity.Comp.SupportedChannels[i];
+            if (!_prototype.TryIndex(channel, out var prototype))
                 continue;
 
             _channels.Add(channel);
             ChannelOptions.AddItem(Loc.GetString(prototype.Name), i);
 
-            if (channel == state.SelectedChannel)
+            if (channel == entity.Comp.CurrentChannel)
                 ChannelOptions.Select(i);
         }
+
+        if (entity.Comp.SupportedChannels.Count == 0)
+        {
+            ChannelOptions.AddItem(Loc.GetString("intercom-options-none"), 0);
+            ChannelOptions.Select(0);
+        }
+
         ChannelOptions.OnItemSelected += args =>
         {
+            if (!_channels.TryGetValue(args.Id, out var proto))
+                return;
+
             ChannelOptions.SelectId(args.Id);
-            OnChannelSelected?.Invoke(_channels[args.Id]);
+            OnChannelSelected?.Invoke(proto);
         };
     }
 }

Content.Client/Shuttles/UI/MapScreen.xaml.cs

@@ -261,7 +261,7 @@ private void RebuildMapObjects()
             ourMap = shuttleXform.MapID;
         }
 
-        while (mapComps.MoveNext(out var mapComp, out var mapXform, out var mapMetadata))
+        while (mapComps.MoveNext(out var mapUid, out var mapComp, out var mapXform, out var mapMetadata))
         {
             if (_console != null && !_shuttles.CanFTLTo(_shuttleEntity.Value, mapComp.MapId, _console.Value))
             {
@@ -327,20 +327,28 @@ private void RebuildMapObjects()
                 {
                     AddMapObject(mapComp.MapId, gridObj);
                 }
-                else if (!_shuttles.IsBeaconMap(_mapManager.GetMapEntityId(mapComp.MapId)) && (iffComp == null ||
-                         (iffComp.Flags & IFFFlags.Hide) == 0x0))
+                // If we can show it then add it to pending.
+                else if (!_shuttles.IsBeaconMap(mapUid) && (iffComp == null ||
+                         (iffComp.Flags & IFFFlags.Hide) == 0x0) &&
+                         !gridObj.HideButton)
                 {
                     _pendingMapObjects.Add((mapComp.MapId, gridObj));
                 }
             }
 
             foreach (var (beacon, _) in _shuttles.GetExclusions(mapComp.MapId, _exclusions))
             {
+                if (beacon.HideButton)
+                    continue;
+
                 _pendingMapObjects.Add((mapComp.MapId, beacon));
             }
 
             foreach (var (beacon, _) in _shuttles.GetBeacons(mapComp.MapId, _beacons))
             {
+                if (beacon.HideButton)
+                    continue;
+
                 _pendingMapObjects.Add((mapComp.MapId, beacon));
             }
 
@@ -425,9 +433,6 @@ private void AddMapObject(MapId mapId, IMapObject mapObj)
         var existing = _mapObjects.GetOrNew(mapId);
         existing.Add(mapObj);
 
-        if (mapObj.HideButton)
-            return;
-
         var gridContents = _mapHeadings[mapId];
 
         var gridButton = new Button()

Content.Server/Ame/AmeNodeGroup.cs

@@ -134,22 +134,11 @@ public float InjectFuel(int fuel, out bool overloading)
         // The AME is being overloaded.
         // Note about these maths: I would assume the general idea here is to make larger engines less safe to overload.
         // In other words, yes, those are supposed to be CoreCount, not safeFuelLimit.
-        var instability = 0;
         var overloadVsSizeResult = fuel - CoreCount;
 
-        // fuel > safeFuelLimit: Slow damage. Can safely run at this level for burst periods if the engine is small and someone is keeping an eye on it.
-        if (_random.Prob(0.5f))
-            instability = 1;
-        // overloadVsSizeResult > 5:
-        if (overloadVsSizeResult > 5)
-            instability = 3;
-        // overloadVsSizeResult > 10: This will explode in at most 20 injections.
-        if (overloadVsSizeResult > 10)
-            instability = 5;
-
-        // Apply calculated instability
-        if (instability == 0)
-            return powerOutput;
+        var instability = overloadVsSizeResult / CoreCount;
+        var fuzz = _random.Next(-1, 2); // -1 to 1
+        instability += fuzz; // fuzz the values a tiny bit.
 
         overloading = true;
         var integrityCheck = 100;
@@ -179,10 +168,12 @@ public float InjectFuel(int fuel, out bool overloading)
     /// </summary>
     public float CalculatePower(int fuel, int cores)
     {
-        // Fuel is squared so more fuel vastly increases power and efficiency
-        // We divide by the number of cores so a larger AME is less efficient at the same fuel settings
-        // this results in all AMEs having the same efficiency at the same fuel-per-core setting
-        return 20000f * fuel * fuel / cores;
+        // Balanced around a single core AME with injection level 2 producing 120KW.
+        // Overclocking yields diminishing returns until it evens out at around 360KW.
+
+        // The adjustment for cores make it so that a 1 core AME at 2 injections is better than a 2 core AME at 2 injections.
+        // However, for the relative amounts for each (1 core at 2 and 2 core at 4), more cores has more output.
+        return 200000f * MathF.Log10(fuel * fuel) * MathF.Pow(0.75f, cores - 1);
     }
 
     public int GetTotalStability()

Content.Server/Ame/EntitySystems/AmeControllerSystem.cs

@@ -274,9 +274,9 @@ public void SetInjectionAmount(EntityUid uid, int value, EntityUid? user = null,
         At the time of editing, players regularly "overclock" the AME and those cases require no admin attention.
 
         // Admin alert
-        var safeLimit = 0;
+        var safeLimit = int.MaxValue;
         if (TryGetAMENodeGroup(uid, out var group))
-            safeLimit = group.CoreCount * 2;
+            safeLimit = group.CoreCount * 4;
 
         if (oldValue <= safeLimit && value > safeLimit)
         {
@@ -291,10 +291,20 @@ public void SetInjectionAmount(EntityUid uid, int value, EntityUid? user = null,
         */
     }
 
-    public void AdjustInjectionAmount(EntityUid uid, int delta, int min = 0, int max = int.MaxValue, EntityUid? user = null, AmeControllerComponent? controller = null)
+    public void AdjustInjectionAmount(EntityUid uid, int delta, EntityUid? user = null, AmeControllerComponent? controller = null)
     {
-        if (Resolve(uid, ref controller))
-            SetInjectionAmount(uid, MathHelper.Clamp(controller.InjectionAmount + delta, min, max), user, controller);
+        if (!Resolve(uid, ref controller))
+            return;
+
+        var max = GetMaxInjectionAmount((uid, controller));
+        SetInjectionAmount(uid, MathHelper.Clamp(controller.InjectionAmount + delta, 0, max), user, controller);
+    }
+
+    public int GetMaxInjectionAmount(Entity<AmeControllerComponent> ent)
+    {
+        if (!TryGetAMENodeGroup(ent, out var group))
+            return 0;
+        return  group.CoreCount * 8;
     }
 
     private void UpdateDisplay(EntityUid uid, int stability, AmeControllerComponent? controller = null, AppearanceComponent? appearance = null)

Content.Server/Body/Systems/InternalsSystem.cs

@@ -100,7 +100,7 @@ public void ToggleInternals(
         // Toggle off if they're on
         if (AreInternalsWorking(internals))
         {
-            if (force || user == uid)
+            if (force)
             {
                 DisconnectTank(internals);
                 return;

Content.Server/Chemistry/EntitySystems/ReactionMixerSystem.cs

@@ -1,6 +1,9 @@
+using Content.Shared.Chemistry.Components;
 using Content.Shared.Chemistry.Reaction;
+using Content.Shared.DoAfter;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Interaction;
+using Content.Shared.Nutrition.EntitySystems;
 using Content.Server.Chemistry.Containers.EntitySystems;
 using Content.Server.Popups;
 
@@ -10,34 +13,68 @@ public sealed partial class ReactionMixerSystem : EntitySystem
 {
     [Dependency] private readonly PopupSystem _popup = default!;
     [Dependency] private readonly SolutionContainerSystem _solutionContainers = default!;
+    [Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
 
     public override void Initialize()
     {
         base.Initialize();
 
         SubscribeLocalEvent<ReactionMixerComponent, AfterInteractEvent>(OnAfterInteract);
+        SubscribeLocalEvent<ReactionMixerComponent, ShakeEvent>(OnShake);
+        SubscribeLocalEvent<ReactionMixerComponent, ReactionMixDoAfterEvent>(OnDoAfter);
     }
 
     private void OnAfterInteract(Entity<ReactionMixerComponent> entity, ref AfterInteractEvent args)
     {
-        if (!args.Target.HasValue || !args.CanReach)
+        if (!args.Target.HasValue || !args.CanReach || !entity.Comp.MixOnInteract)
             return;
 
-        var mixAttemptEvent = new MixingAttemptEvent(entity);
-        RaiseLocalEvent(entity, ref mixAttemptEvent);
-        if (mixAttemptEvent.Cancelled)
-        {
+        if (!MixAttempt(entity, args.Target.Value, out var solution))
             return;
-        }
 
-        if (!_solutionContainers.TryGetMixableSolution(args.Target.Value, out var solution, out _))
+        var doAfterArgs = new DoAfterArgs(EntityManager, args.User, entity.Comp.TimeToMix, new ReactionMixDoAfterEvent(), entity, args.Target.Value, entity);
+
+        _doAfterSystem.TryStartDoAfter(doAfterArgs);
+    }
+
+    private void OnDoAfter(Entity<ReactionMixerComponent> entity, ref ReactionMixDoAfterEvent args)
+    {
+        //Do again to get the solution again
+        if (!MixAttempt(entity, args.Target!.Value, out var solution))
             return;
 
-        _popup.PopupEntity(Loc.GetString(entity.Comp.MixMessage, ("mixed", Identity.Entity(args.Target.Value, EntityManager)), ("mixer", Identity.Entity(entity.Owner, EntityManager))), args.User, args.User);
+        _popup.PopupEntity(Loc.GetString(entity.Comp.MixMessage, ("mixed", Identity.Entity(args.Target!.Value, EntityManager)), ("mixer", Identity.Entity(entity.Owner, EntityManager))), args.User, args.User);
+
+        _solutionContainers.UpdateChemicals(solution!.Value, true, entity.Comp);
+
+        var afterMixingEvent = new AfterMixingEvent(entity, args.Target!.Value);
+        RaiseLocalEvent(entity, afterMixingEvent);
+    }
+
+    private void OnShake(Entity<ReactionMixerComponent> entity, ref ShakeEvent args)
+    {
+        if (!MixAttempt(entity, entity, out var solution))
+            return;
 
-        _solutionContainers.UpdateChemicals(solution.Value, true, entity.Comp);
+        _solutionContainers.UpdateChemicals(solution!.Value, true, entity.Comp);
 
-        var afterMixingEvent = new AfterMixingEvent(entity, args.Target.Value);
+        var afterMixingEvent = new AfterMixingEvent(entity, entity);
         RaiseLocalEvent(entity, afterMixingEvent);
     }
+
+    private bool MixAttempt(EntityUid ent, EntityUid target, out Entity<SolutionComponent>? solution)
+    {
+        solution = null;
+        var mixAttemptEvent = new MixingAttemptEvent(ent);
+        RaiseLocalEvent(ent, ref mixAttemptEvent);
+        if (mixAttemptEvent.Cancelled)
+        {
+            return false;
+        }
+
+        if (!_solutionContainers.TryGetMixableSolution(target, out solution, out _))
+            return false;
+
+        return true;
+    }
 }

Content.Server/EntityEffects/Effects/AreaReactionEffect.cs

@@ -1,4 +1,5 @@
 using Content.Server.Fluids.EntitySystems;
+using Content.Server.Spreader;
 using Content.Shared.Audio;
 using Content.Shared.Coordinates.Helpers;
 using Content.Shared.Database;
@@ -64,16 +65,19 @@ public override void Effect(EntityEffectBaseArgs args)
             var transform = reagentArgs.EntityManager.GetComponent<TransformComponent>(reagentArgs.TargetEntity);
             var mapManager = IoCManager.Resolve<IMapManager>();
             var mapSys = reagentArgs.EntityManager.System<MapSystem>();
-            var sys = reagentArgs.EntityManager.System<TransformSystem>();
+            var spreaderSys = args.EntityManager.System<SpreaderSystem>();
+            var sys = args.EntityManager.System<TransformSystem>();
             var mapCoords = sys.GetMapCoordinates(reagentArgs.TargetEntity, xform: transform);
 
             if (!mapManager.TryFindGridAt(mapCoords, out var gridUid, out var grid) ||
-                !mapSys.TryGetTileRef(gridUid, grid, transform.Coordinates, out var tileRef) ||
-                tileRef.Tile.IsSpace())
+                !mapSys.TryGetTileRef(gridUid, grid, transform.Coordinates, out var tileRef))
             {
                 return;
             }
 
+            if (spreaderSys.RequiresFloorToSpread(_prototypeId) && tileRef.Tile.IsSpace())
+                return;
+
             var coords = mapSys.MapToGrid(gridUid, mapCoords);
             var ent = reagentArgs.EntityManager.SpawnEntity(_prototypeId, coords.SnapToGrid());