Merge branch 'master' into LambdaFix

Content.Client/Chemistry/EntitySystems/FillableOneTimeInjectorSystem.cs

@@ -0,0 +1,16 @@
+using Content.Client.Chemistry.UI;
+using Content.Client.Items;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Robust.Shared.GameStates;
+
+namespace Content.Client.Chemistry.EntitySystems;
+
+public sealed class FillableOneTimeInjectorSystem : SharedFillableOneTimeInjectorSystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+        Subs.ItemStatus<FillableOneTimeInjectorComponent>(ent => new FillableOneTimeInjectorStatusControl(ent, SolutionContainers));
+    }
+}

Content.Client/Chemistry/UI/FillableOneTimeInjectorStatusControl.cs

@@ -0,0 +1,84 @@
+using Content.Client.Message;
+using Content.Client.Stylesheets;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Chemistry.EntitySystems;
+using Content.Shared.FixedPoint;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Timing;
+
+namespace Content.Client.Chemistry.UI;
+
+public sealed class FillableOneTimeInjectorStatusControl : Control
+{
+    private readonly Entity<FillableOneTimeInjectorComponent> _parent;
+    private readonly SharedSolutionContainerSystem _solutionContainers;
+    private readonly RichTextLabel _label;
+
+    private FixedPoint2 PrevVolume;
+    private FixedPoint2 PrevMaxVolume;
+    private FixedPoint2 PrevTransferAmount;
+    private FillableOneTimeInjectorToggleMode PrevToggleStateIndex;
+
+    public FillableOneTimeInjectorStatusControl(Entity<FillableOneTimeInjectorComponent> parent, SharedSolutionContainerSystem solutionContainers)
+    {
+        _parent = parent;
+        _solutionContainers = solutionContainers;
+        _label = new RichTextLabel { StyleClasses = { StyleNano.StyleClassItemStatus } };
+        AddChild(_label);
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        base.FrameUpdate(args);
+
+        if (!_solutionContainers.TryGetSolution(_parent.Owner, _parent.Comp.SolutionName, out _, out var solution))
+            return;
+
+        // only updates the UI if any of the details are different than they previously were
+        if (PrevVolume == solution.Volume
+            && PrevMaxVolume == solution.MaxVolume
+            && PrevTransferAmount == _parent.Comp.TransferAmount)
+            return;
+
+        PrevVolume = solution.Volume;
+        PrevMaxVolume = solution.MaxVolume;
+        PrevTransferAmount = _parent.Comp.TransferAmount;
+        var modeStringLocalized = "";
+
+        // only updates the UI if any of the details are different than they previously were
+        if(PrevToggleStateIndex == _parent.Comp.ToggleState)
+            return;
+
+        PrevToggleStateIndex = _parent.Comp.ToggleState;
+
+        // Update current volume and injector state
+        modeStringLocalized = Loc.GetString(
+            _parent.Comp.ToggleState switch
+            {
+                FillableOneTimeInjectorToggleMode.Draw => "injector-draw-text",
+                FillableOneTimeInjectorToggleMode.Inject => "injector-inject-text",
+                FillableOneTimeInjectorToggleMode.Spent => "injector-spent-text",
+                _ => "injector-invalid-injector-toggle-mode"
+            });
+
+        if (_parent.Comp.ToggleState != FillableOneTimeInjectorToggleMode.Draw)
+        {
+            _label.SetMarkup(
+                Loc.GetString(
+                    "onetime-injector-simple-volume-label",
+                    ("currentVolume", solution.Volume),
+                    ("modeString", modeStringLocalized)));
+        }
+        else
+        {
+            _label.SetMarkup(
+                Loc.GetString(
+                    "injector-volume-label",
+                    ("currentVolume", solution.Volume),
+                    ("totalVolume", solution.MaxVolume),
+                    ("modeString", modeStringLocalized),
+                    ("transferVolume", _parent.Comp.TransferAmount)));
+        }
+    }
+}

Content.Client/DeltaV/CartridgeLoader/Cartridges/StockTradingUi.cs

@@ -36,7 +36,7 @@ public override void UpdateState(BoundUserInterfaceState state)
         }
     }
 
-    private static void SendStockTradingUiMessage(StockTradingUiAction action, int company, float amount, BoundUserInterface userInterface)
+    private static void SendStockTradingUiMessage(StockTradingUiAction action, int company, int amount, BoundUserInterface userInterface)
     {
         var newsMessage = new StockTradingUiMessageEvent(action, company, amount);
         var message = new CartridgeUiMessage(newsMessage);

Content.Client/DeltaV/CartridgeLoader/Cartridges/StockTradingUiFragment.xaml.cs

@@ -14,8 +14,8 @@ public sealed partial class StockTradingUiFragment : BoxContainer
     private readonly Dictionary<int, CompanyEntry> _companyEntries = new();
 
     // Event handlers for the parent UI
-    public event Action<int, float>? OnBuyButtonPressed;
-    public event Action<int, float>? OnSellButtonPressed;
+    public event Action<int, int>? OnBuyButtonPressed;
+    public event Action<int, int>? OnSellButtonPressed;
 
     // Define colors
     public static readonly Color PositiveColor = Color.FromHex("#00ff00"); // Green
@@ -70,8 +70,8 @@ private sealed class CompanyEntry
 
         public CompanyEntry(int companyIndex,
             string displayName,
-            Action<int, float>? onBuyPressed,
-            Action<int, float>? onSellPressed)
+            Action<int, int>? onBuyPressed,
+            Action<int, int>? onSellPressed)
         {
             Container = new BoxContainer
             {
@@ -216,13 +216,13 @@ public CompanyEntry(int companyIndex,
             // Button click events
             _buyButton.OnPressed += _ =>
             {
-                if (float.TryParse(_amountEdit.Text, out var amount) && amount > 0)
+                if (int.TryParse(_amountEdit.Text, out var amount) && amount > 0)
                     onBuyPressed?.Invoke(companyIndex, amount);
             };
 
             _sellButton.OnPressed += _ =>
             {
-                if (float.TryParse(_amountEdit.Text, out var amount) && amount > 0)
+                if (int.TryParse(_amountEdit.Text, out var amount) && amount > 0)
                     onSellPressed?.Invoke(companyIndex, amount);
             };
 
@@ -235,7 +235,7 @@ public CompanyEntry(int companyIndex,
             };
         }
 
-        public void Update(StockCompanyStruct company, int ownedStocks)
+        public void Update(StockCompany company, int ownedStocks)
         {
             _nameLabel.Text = company.LocalizedDisplayName;
             _priceLabel.Text = $"${company.CurrentPrice:F2}";

Content.Client/Guidebook/Controls/GuidebookWindow.xaml

@@ -2,7 +2,7 @@
                 xmlns:cc="clr-namespace:Content.Client.Administration.UI.CustomControls"
                 xmlns:fancyTree="clr-namespace:Content.Client.UserInterface.Controls.FancyTree"
                 xmlns:controls="clr-namespace:Content.Client.UserInterface.Controls"
-                SetSize="750 700"
+                SetSize="850 700"
                 MinSize="100 200"
                 Resizable="True"
                 Title="{Loc 'guidebook-window-title'}">
@@ -21,9 +21,13 @@
                     Margin="0 5 10 5">
                 </LineEdit>
             </BoxContainer>
+            <BoxContainer Access="Internal" Name="ReturnContainer" Orientation="Horizontal" HorizontalAlignment="Right" Visible="False">
+                <Button Name="HomeButton" Text="{Loc 'ui-rules-button-home'}" Margin="0 0 10 0"/>
+            </BoxContainer>
             <ScrollContainer Name="Scroll" HScrollEnabled="False" HorizontalExpand="True" VerticalExpand="True">
                 <Control>
-                    <BoxContainer Orientation="Vertical" Name="EntryContainer" Margin="5 5 5 5" Visible="False"/>
+                    <BoxContainer Orientation="Vertical" Name="EntryContainer" Margin="5 5 5 5" Visible="False">
+                    </BoxContainer>
                     <BoxContainer Orientation="Vertical" Name="Placeholder" Margin="5 5 5 5">
                         <Label HorizontalAlignment="Center" VerticalAlignment="Center" Text="{Loc 'guidebook-placeholder-text'}"/>
                         <Label HorizontalAlignment="Center" VerticalAlignment="Center" Text="{Loc 'guidebook-placeholder-text-2'}"/>

Content.Client/Guidebook/Controls/GuidebookWindow.xaml.cs

@@ -5,11 +5,13 @@
 using Content.Client.UserInterface.Controls;
 using Content.Client.UserInterface.Controls.FancyTree;
 using JetBrains.Annotations;
+using Content.Client.UserInterface.Systems.Info;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.ContentPack;
+using Robust.Shared.Prototypes;
 
 namespace Content.Client.Guidebook.Controls;
 
@@ -21,6 +23,8 @@ public sealed partial class GuidebookWindow : FancyWindow, ILinkClickHandler
 
     private Dictionary<string, GuideEntry> _entries = new();
 
+    public ProtoId<GuideEntryPrototype> LastEntry;
+
     public GuidebookWindow()
     {
         RobustXamlLoader.Load(this);
@@ -37,7 +41,13 @@ public GuidebookWindow()
     private void OnSelectionChanged(TreeItem? item)
     {
         if (item != null && item.Metadata is GuideEntry entry)
+        {
             ShowGuide(entry);
+
+            var isRulesEntry = entry.RuleEntry;
+            ReturnContainer.Visible = isRulesEntry;
+            HomeButton.OnPressed += _ => ShowGuide(entry);
+        }
         else
             ClearSelectedGuide();
     }
@@ -66,6 +76,8 @@ private void ShowGuide(GuideEntry entry)
             EntryContainer.AddChild(new Label() { Text = "ERROR: Failed to parse document." });
             Logger.Error($"Failed to parse contents of guide document {entry.Id}.");
         }
+
+        LastEntry = entry.Id;
     }
 
     public void UpdateGuides(
@@ -152,6 +164,10 @@ private void RepopulateTree(List<string>? roots = null, string? forcedRoot = nul
             return null;
         }
 
+        var rulesProto = UserInterfaceManager.GetUIController<InfoUIController>().GetCoreRuleEntry();
+        if (entry.RuleEntry && entry.Id != rulesProto.Id)
+            return null;
+
         var item = Tree.AddItem(parent);
         item.Metadata = entry;
         var name = Loc.GetString(entry.Name);

Content.Client/Guidebook/GuideEntry.cs

@@ -34,6 +34,8 @@ public class GuideEntry
     /// </summary>
     [DataField("filterEnabled")] public bool FilterEnabled = default!;
 
+    [DataField] public bool RuleEntry;
+
     /// <summary>
     ///     Priority for sorting top-level guides when shown in a tree / table of contents.
     ///     If the guide is the child of some other guide, the order simply determined by the order of children in <see cref="Children"/>.

Content.Client/Light/AfterLightTargetOverlay.cs

@@ -0,0 +1,58 @@
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+
+namespace Content.Client.Light;
+
+/// <summary>
+/// This exists just to copy <see cref="BeforeLightTargetOverlay"/> to the light render target
+/// </summary>
+public sealed class AfterLightTargetOverlay : Overlay
+{
+    public override OverlaySpace Space => OverlaySpace.BeforeLighting;
+
+    [Dependency] private readonly IOverlayManager _overlay = default!;
+
+    public const int ContentZIndex = LightBlurOverlay.ContentZIndex + 1;
+
+    public AfterLightTargetOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        ZIndex = ContentZIndex;
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        var viewport = args.Viewport;
+        var worldHandle = args.WorldHandle;
+
+        if (viewport.Eye == null)
+            return;
+
+        var lightOverlay = _overlay.GetOverlay<BeforeLightTargetOverlay>();
+        var bounds = args.WorldBounds;
+
+        // at 1-1 render scale it's mostly fine but at 4x4 it's way too fkn big
+        var newScale = viewport.RenderScale / 2f;
+
+        var localMatrix =
+            viewport.LightRenderTarget.GetWorldToLocalMatrix(viewport.Eye, newScale);
+        var diff = (lightOverlay.EnlargedLightTarget.Size - viewport.LightRenderTarget.Size);
+        var halfDiff = diff / 2;
+
+        // Pixels -> Metres -> Half distance.
+        // If we're zoomed in need to enlarge the bounds further.
+        args.WorldHandle.RenderInRenderTarget(viewport.LightRenderTarget,
+            () =>
+            {
+                // We essentially need to draw the cropped version onto the lightrendertarget.
+                var subRegion = new UIBox2i(halfDiff.X,
+                    halfDiff.Y,
+                    viewport.LightRenderTarget.Size.X + halfDiff.X,
+                    viewport.LightRenderTarget.Size.Y + halfDiff.Y);
+
+                worldHandle.SetTransform(localMatrix);
+                worldHandle.DrawTextureRectRegion(lightOverlay.EnlargedLightTarget.Texture, bounds, subRegion: subRegion);
+            }, null);
+    }
+}

Content.Client/Light/BeforeLightTargetOverlay.cs

@@ -0,0 +1,51 @@
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+
+namespace Content.Client.Light;
+
+/// <summary>
+/// Handles an enlarged lighting target so content can use large blur radii.
+/// </summary>
+public sealed class BeforeLightTargetOverlay : Overlay
+{
+    public override OverlaySpace Space => OverlaySpace.BeforeLighting;
+
+    [Dependency] private readonly IClyde _clyde = default!;
+
+    public IRenderTexture EnlargedLightTarget = default!;
+    public Box2Rotated EnlargedBounds;
+
+    /// <summary>
+    /// In metres
+    /// </summary>
+    private float _skirting = 1.5f;
+
+    public const int ContentZIndex = -10;
+
+    public BeforeLightTargetOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        ZIndex = ContentZIndex;
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        // Code is weird but I don't think engine should be enlarging the lighting render target arbitrarily either, maybe via cvar?
+        // The problem is the blur has no knowledge of pixels outside the viewport so with a large enough blur radius you get sampling issues.
+        var size = args.Viewport.LightRenderTarget.Size + (int) (_skirting * EyeManager.PixelsPerMeter);
+        EnlargedBounds = args.WorldBounds.Enlarged(_skirting / 2f);
+
+        // This just exists to copy the lightrendertarget and write back to it.
+        if (EnlargedLightTarget?.Size != size)
+        {
+            EnlargedLightTarget = _clyde
+                .CreateRenderTarget(size, new RenderTargetFormatParameters(RenderTargetColorFormat.Rgba8Srgb), name: "enlarged-light-copy");
+        }
+
+        args.WorldHandle.RenderInRenderTarget(EnlargedLightTarget,
+            () =>
+            {
+            }, _clyde.GetClearColor(args.MapUid));
+    }
+}

Content.Client/Light/EntitySystems/PlanetLightSystem.cs

@@ -0,0 +1,36 @@
+using Robust.Client.Graphics;
+
+namespace Content.Client.Light.EntitySystems;
+
+public sealed class PlanetLightSystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<GetClearColorEvent>(OnClearColor);
+
+        _overlayMan.AddOverlay(new BeforeLightTargetOverlay());
+        _overlayMan.AddOverlay(new RoofOverlay(EntityManager));
+        _overlayMan.AddOverlay(new TileEmissionOverlay(EntityManager));
+        _overlayMan.AddOverlay(new LightBlurOverlay());
+        _overlayMan.AddOverlay(new AfterLightTargetOverlay());
+    }
+
+    private void OnClearColor(ref GetClearColorEvent ev)
+    {
+        ev.Color = Color.Transparent;
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _overlayMan.RemoveOverlay<BeforeLightTargetOverlay>();
+        _overlayMan.RemoveOverlay<RoofOverlay>();
+        _overlayMan.RemoveOverlay<TileEmissionOverlay>();
+        _overlayMan.RemoveOverlay<LightBlurOverlay>();
+        _overlayMan.RemoveOverlay<AfterLightTargetOverlay>();
+    }
+}