Merge branch 'master' into nlr-clarification

.github/workflows/conflict-labeler.yml → .github/workflows/labeler-conflict.yml

@@ -16,6 +16,6 @@ jobs:
       - name: Check for Merge Conflicts
         uses: eps1lon/[email protected]
         with:
-          dirtyLabel: "Status: Merge Conflict"
+          dirtyLabel: "S: Merge Conflict"
           repoToken: "${{ secrets.GITHUB_TOKEN }}"
           commentOnDirty: "This pull request has conflicts, please resolve those before we can evaluate the pull request."

.github/workflows/labeler-needsreview.yml

@@ -10,7 +10,7 @@ jobs:
     steps:
     - uses: actions-ecosystem/action-add-labels@v1
       with:
-        labels: "Status: Needs Review"
+        labels: "S: Needs Review"
     - uses: actions-ecosystem/action-remove-labels@v1
       with:
-        labels: "Status: Awaiting Changes"
+        labels: "S: Awaiting Changes"

.github/workflows/labeler-size.yml

@@ -0,0 +1,21 @@
+name: "Labels: Size"
+on: pull_request_target
+jobs:
+  size-label:
+    runs-on: ubuntu-latest
+    steps:
+      - name: size-label
+        uses: "pascalgn/[email protected]"
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+        with:
+          # Custom size configuration
+          # DeltaV: changed to powers of 4
+          sizes: >
+            {
+              "0": "XS",
+              "16": "S",
+              "64": "M",
+              "256": "L",
+              "1024": "XL"
+            }

.github/workflows/labeler-untriaged.yml

@@ -3,6 +3,8 @@
 on:
   issues:
     types: [opened]
+  pull_request_target:
+    types: [opened]
 
 jobs:
   add_label:
@@ -11,4 +13,4 @@ jobs:
     - uses: actions-ecosystem/action-add-labels@v1
       if: join(github.event.issue.labels) == ''
       with:
-        labels: "Status: Untriaged"
+        labels: "S: Untriaged"

Content.Client/Administration/UI/Notes/NoteEdit.xaml

@@ -8,6 +8,7 @@
             <Label Name="ExpiryLabel" Text="{Loc admin-note-editor-expiry-label}" Visible="False" />
             <HistoryLineEdit Name="ExpiryLineEdit" PlaceHolder="{Loc admin-note-editor-expiry-placeholder}"
                              Visible="False" HorizontalExpand="True" />
+            <OptionButton Name="ExpiryLengthDropdown" Visible="False" />
         </BoxContainer>
         <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
             <OptionButton Name="TypeOption" HorizontalAlignment="Center" />

Content.Client/Administration/UI/Notes/NoteEdit.xaml.cs

@@ -17,6 +17,17 @@ public sealed partial class NoteEdit : FancyWindow
     [Dependency] private readonly IGameTiming _gameTiming = default!;
     [Dependency] private readonly IClientConsoleHost _console = default!;
 
+    private enum Multipliers
+    {
+        Minutes,
+        Hours,
+        Days,
+        Weeks,
+        Months,
+        Years,
+        Centuries
+    }
+
     public event Action<int, NoteType, string, NoteSeverity?, bool, DateTime?>? SubmitPressed;
 
     public NoteEdit(SharedAdminNote? note, string playerName, bool canCreate, bool canEdit)
@@ -31,6 +42,20 @@ public NoteEdit(SharedAdminNote? note, string playerName, bool canCreate, bool c
 
         ResetSubmitButton();
 
+        // It's weird to use minutes as the IDs, but it works and makes sense kind of :)
+        ExpiryLengthDropdown.AddItem(Loc.GetString("admin-note-button-minutes"), (int) Multipliers.Minutes);
+        ExpiryLengthDropdown.AddItem(Loc.GetString("admin-note-button-hours"), (int) Multipliers.Hours);
+        ExpiryLengthDropdown.AddItem(Loc.GetString("admin-note-button-days"), (int) Multipliers.Days);
+        ExpiryLengthDropdown.AddItem(Loc.GetString("admin-note-button-weeks"), (int) Multipliers.Weeks);
+        ExpiryLengthDropdown.AddItem(Loc.GetString("admin-note-button-months"), (int) Multipliers.Months);
+        ExpiryLengthDropdown.AddItem(Loc.GetString("admin-note-button-years"), (int) Multipliers.Years);
+        ExpiryLengthDropdown.AddItem(Loc.GetString("admin-note-button-centuries"), (int) Multipliers.Centuries);
+        ExpiryLengthDropdown.OnItemSelected += OnLengthChanged;
+
+        ExpiryLengthDropdown.SelectId((int) Multipliers.Weeks);
+
+        ExpiryLineEdit.OnTextChanged += OnTextChanged;
+
         TypeOption.AddItem(Loc.GetString("admin-note-editor-type-note"), (int) NoteType.Note);
         TypeOption.AddItem(Loc.GetString("admin-note-editor-type-message"), (int) NoteType.Message);
         TypeOption.AddItem(Loc.GetString("admin-note-editor-type-watchlist"), (int) NoteType.Watchlist);
@@ -172,8 +197,9 @@ private void UpdatePermanentCheckboxFields()
     {
         ExpiryLabel.Visible = !PermanentCheckBox.Pressed;
         ExpiryLineEdit.Visible = !PermanentCheckBox.Pressed;
+        ExpiryLengthDropdown.Visible = !PermanentCheckBox.Pressed;
 
-        ExpiryLineEdit.Text = !PermanentCheckBox.Pressed ? DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") : string.Empty;
+        ExpiryLineEdit.Text = !PermanentCheckBox.Pressed ? 1.ToString() : string.Empty;
     }
 
     private void OnSecretPressed(BaseButton.ButtonEventArgs _)
@@ -187,6 +213,16 @@ private void OnSeverityChanged(OptionButton.ItemSelectedEventArgs args)
         SeverityOption.SelectId(args.Id);
     }
 
+    private void OnLengthChanged(OptionButton.ItemSelectedEventArgs args)
+    {
+        ExpiryLengthDropdown.SelectId(args.Id);
+    }
+
+    private void OnTextChanged(HistoryLineEdit.LineEditEventArgs args)
+    {
+        ParseExpiryTime();
+    }
+
     private void OnSubmitButtonPressed(BaseButton.ButtonEventArgs args)
     {
         if (!ParseExpiryTime())
@@ -263,13 +299,24 @@ private bool ParseExpiryTime()
             return true;
         }
 
-        if (string.IsNullOrWhiteSpace(ExpiryLineEdit.Text) || !DateTime.TryParse(ExpiryLineEdit.Text, out var result) || DateTime.UtcNow > result)
+        if (string.IsNullOrWhiteSpace(ExpiryLineEdit.Text) || !uint.TryParse(ExpiryLineEdit.Text, out var inputInt))
         {
             ExpiryLineEdit.ModulateSelfOverride = Color.Red;
             return false;
         }
 
-        ExpiryTime = result.ToUniversalTime();
+        var mult = ExpiryLengthDropdown.SelectedId switch
+        {
+            (int) Multipliers.Minutes => TimeSpan.FromMinutes(1).TotalMinutes,
+            (int) Multipliers.Hours => TimeSpan.FromHours(1).TotalMinutes,
+            (int) Multipliers.Days => TimeSpan.FromDays(1).TotalMinutes,
+            (int) Multipliers.Weeks => TimeSpan.FromDays(7).TotalMinutes,
+            (int) Multipliers.Months => TimeSpan.FromDays(30).TotalMinutes,
+            (int) Multipliers.Years => TimeSpan.FromDays(365).TotalMinutes,
+            (int) Multipliers.Centuries => TimeSpan.FromDays(36525).TotalMinutes,
+            _ => throw new ArgumentOutOfRangeException(nameof(ExpiryLengthDropdown.SelectedId), "Multiplier out of range :(")
+        };
+        ExpiryTime = DateTime.UtcNow.AddMinutes(inputInt * mult);
         ExpiryLineEdit.ModulateSelfOverride = null;
         return true;
     }

Content.Client/Alerts/ClientAlertsSystem.cs

@@ -2,6 +2,7 @@
 using Content.Shared.Alert;
 using JetBrains.Annotations;
 using Robust.Client.Player;
+using Robust.Shared.GameStates;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 
@@ -24,8 +25,7 @@ public override void Initialize()
 
         SubscribeLocalEvent<AlertsComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
         SubscribeLocalEvent<AlertsComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
-
-        SubscribeLocalEvent<AlertsComponent, AfterAutoHandleStateEvent>(ClientAlertsHandleState);
+        SubscribeLocalEvent<AlertsComponent, ComponentHandleState>(OnHandleState);
     }
     protected override void LoadPrototypes()
     {
@@ -47,17 +47,22 @@ public IReadOnlyDictionary<AlertKey, AlertState>? ActiveAlerts
         }
     }
 
-    protected override void AfterShowAlert(Entity<AlertsComponent> alerts)
+    private void OnHandleState(Entity<AlertsComponent> alerts, ref ComponentHandleState args)
     {
+        if (args.Current is not AlertComponentState cast)
+            return;
+
+        alerts.Comp.Alerts = cast.Alerts;
+
         UpdateHud(alerts);
     }
 
-    protected override void AfterClearAlert(Entity<AlertsComponent> alerts)
+    protected override void AfterShowAlert(Entity<AlertsComponent> alerts)
     {
         UpdateHud(alerts);
     }
 
-    private void ClientAlertsHandleState(Entity<AlertsComponent> alerts, ref AfterAutoHandleStateEvent args)
+    protected override void AfterClearAlert(Entity<AlertsComponent> alerts)
     {
         UpdateHud(alerts);
     }

Content.Client/Clothing/ClientClothingSystem.cs

@@ -58,6 +58,7 @@ public override void Initialize()
         base.Initialize();
 
         SubscribeLocalEvent<ClothingComponent, GetEquipmentVisualsEvent>(OnGetVisuals);
+        SubscribeLocalEvent<ClothingComponent, InventoryTemplateUpdated>(OnInventoryTemplateUpdated);
 
         SubscribeLocalEvent<InventoryComponent, VisualsChangedEvent>(OnVisualsChanged);
         SubscribeLocalEvent<SpriteComponent, DidUnequipEvent>(OnDidUnequip);
@@ -70,11 +71,7 @@ private void OnAppearanceUpdate(EntityUid uid, InventoryComponent component, ref
         if (args.Sprite == null)
             return;
 
-        var enumerator = _inventorySystem.GetSlotEnumerator((uid, component));
-        while (enumerator.NextItem(out var item, out var slot))
-        {
-            RenderEquipment(uid, item, slot.Name, component);
-        }
+        UpdateAllSlots(uid, component);
 
         // No clothing equipped -> make sure the layer is hidden, though this should already be handled by on-unequip.
         if (args.Sprite.LayerMapTryGet(HumanoidVisualLayers.StencilMask, out var layer))
@@ -84,6 +81,23 @@ private void OnAppearanceUpdate(EntityUid uid, InventoryComponent component, ref
         }
     }
 
+    private void OnInventoryTemplateUpdated(Entity<ClothingComponent> ent, ref InventoryTemplateUpdated args)
+    {
+        UpdateAllSlots(ent.Owner, clothing: ent.Comp);
+    }
+
+    private void UpdateAllSlots(
+        EntityUid uid,
+        InventoryComponent? inventoryComponent = null,
+        ClothingComponent? clothing = null)
+    {
+        var enumerator = _inventorySystem.GetSlotEnumerator((uid, inventoryComponent));
+        while (enumerator.NextItem(out var item, out var slot))
+        {
+            RenderEquipment(uid, item, slot.Name, inventoryComponent, clothingComponent: clothing);
+        }
+    }
+
     private void OnGetVisuals(EntityUid uid, ClothingComponent item, GetEquipmentVisualsEvent args)
     {
         if (!TryComp(args.Equipee, out InventoryComponent? inventory))

Content.Client/Commands/ShowHealthBarsCommand.cs

@@ -1,6 +1,8 @@
+using Content.Shared.Damage.Prototypes;
 using Content.Shared.Overlays;
 using Robust.Client.Player;
 using Robust.Shared.Console;
+using Robust.Shared.Prototypes;
 using System.Linq;
 
 namespace Content.Client.Commands;
@@ -34,7 +36,7 @@ public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             var showHealthBarsComponent = new ShowHealthBarsComponent
             {
-                DamageContainers = args.ToList(),
+                DamageContainers = args.Select(arg => new ProtoId<DamageContainerPrototype>(arg)).ToList(),
                 HealthStatusIcon = null,
                 NetSyncEnabled = false
             };

Content.Client/DeltaV/Overlays/PainOverlay.cs

@@ -0,0 +1,52 @@
+using System.Numerics;
+using Content.Shared.DeltaV.Pain;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.DeltaV.Overlays;
+
+public sealed partial class PainOverlay : Overlay
+{
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly IEntityManager _entity = default!;
+
+    public override bool RequestScreenTexture => true;
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+    private readonly ShaderInstance _painShader;
+    private readonly ProtoId<ShaderPrototype> _shaderProto = "ChromaticAberration";
+
+    public PainOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _painShader = _prototype.Index(_shaderProto).Instance().Duplicate();
+    }
+
+    protected override bool BeforeDraw(in OverlayDrawArgs args)
+    {
+        if (_player.LocalEntity is not { Valid: true } player
+            || !_entity.HasComponent<PainComponent>(player))
+        {
+            return false;
+        }
+
+        return base.BeforeDraw(in args);
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (ScreenTexture is null)
+            return;
+
+        _painShader.SetParameter("SCREEN_TEXTURE", ScreenTexture);
+
+        var worldHandle = args.WorldHandle;
+        var viewport = args.WorldBounds;
+        worldHandle.SetTransform(Matrix3x2.Identity);
+        worldHandle.UseShader(_painShader);
+        worldHandle.DrawRect(viewport, Color.White);
+        worldHandle.UseShader(null);
+    }
+}

Content.Client/DeltaV/Overlays/PainSystem.cs

@@ -0,0 +1,65 @@
+using Content.Shared.DeltaV.Pain;
+using Robust.Client.Graphics;
+using Robust.Shared.Player;
+
+namespace Content.Client.DeltaV.Overlays;
+
+public sealed partial class PainSystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+    [Dependency] private readonly ISharedPlayerManager _playerMan = default!;
+
+    private PainOverlay _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PainComponent, ComponentInit>(OnPainInit);
+        SubscribeLocalEvent<PainComponent, ComponentShutdown>(OnPainShutdown);
+        SubscribeLocalEvent<PainComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<PainComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
+
+        _overlay = new();
+    }
+
+    private void OnPainInit(Entity<PainComponent> ent, ref ComponentInit args)
+    {
+        if (ent.Owner == _playerMan.LocalEntity && !ent.Comp.Suppressed)
+            _overlayMan.AddOverlay(_overlay);
+    }
+
+    private void OnPainShutdown(Entity<PainComponent> ent, ref ComponentShutdown args)
+    {
+        if (ent.Owner == _playerMan.LocalEntity)
+            _overlayMan.RemoveOverlay(_overlay);
+    }
+
+    private void OnPlayerAttached(Entity<PainComponent> ent, ref LocalPlayerAttachedEvent args)
+    {
+        if (!ent.Comp.Suppressed)
+            _overlayMan.AddOverlay(_overlay);
+    }
+
+    private void OnPlayerDetached(Entity<PainComponent> ent, ref LocalPlayerDetachedEvent args)
+    {
+        _overlayMan.RemoveOverlay(_overlay);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        // Handle showing/hiding overlay based on suppression status
+        if (_playerMan.LocalEntity is not { } player)
+            return;
+
+        if (!TryComp<PainComponent>(player, out var comp))
+            return;
+
+        if (comp.Suppressed && _overlayMan.HasOverlay<PainOverlay>())
+            _overlayMan.RemoveOverlay(_overlay);
+        else if (!comp.Suppressed && !_overlayMan.HasOverlay<PainOverlay>())
+            _overlayMan.AddOverlay(_overlay);
+    }
+}