Merge branch 'master' into surgery-port

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/Effects/ColorFlashEffectSystem.cs

@@ -124,6 +124,10 @@ private void OnColorFlashEffect(ColorFlashEffectEvent ev)
                 continue;
             }
 
+            var targetEv = new GetFlashEffectTargetEvent(ent);
+            RaiseLocalEvent(ent, ref targetEv);
+            ent = targetEv.Target;
+
             EnsureComp<ColorFlashEffectComponent>(ent, out comp);
             comp.NetSyncEnabled = false;
             comp.Color = sprite.Color;
@@ -132,3 +136,9 @@ private void OnColorFlashEffect(ColorFlashEffectEvent ev)
         }
     }
 }
+
+/// <summary>
+/// Raised on an entity to change the target for a color flash effect.
+/// </summary>
+[ByRefEvent]
+public record struct GetFlashEffectTargetEvent(EntityUid Target);

Content.Client/Overlays/ShowThirstIconsSystem.cs

@@ -22,6 +22,6 @@ private void OnGetStatusIconsEvent(EntityUid uid, ThirstComponent component, ref
             return;
 
         if (_thirst.TryGetStatusIconPrototype(component, out var iconPrototype))
-            ev.StatusIcons.Add(iconPrototype!);
+            ev.StatusIcons.Add(iconPrototype);
     }
 }

Content.Client/Polymorph/Systems/ChameleonProjectorSystem.cs

@@ -1,7 +1,10 @@
+using Content.Client.Effects;
+using Content.Client.Smoking;
 using Content.Shared.Chemistry.Components;
 using Content.Shared.Polymorph.Components;
 using Content.Shared.Polymorph.Systems;
 using Robust.Client.GameObjects;
+using Robust.Shared.Player;
 
 namespace Content.Client.Polymorph.Systems;
 
@@ -10,24 +13,51 @@ public sealed class ChameleonProjectorSystem : SharedChameleonProjectorSystem
     [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
 
     private EntityQuery<AppearanceComponent> _appearanceQuery;
+    private EntityQuery<SpriteComponent> _spriteQuery;
 
     public override void Initialize()
     {
         base.Initialize();
 
         _appearanceQuery = GetEntityQuery<AppearanceComponent>();
+        _spriteQuery = GetEntityQuery<SpriteComponent>();
 
         SubscribeLocalEvent<ChameleonDisguiseComponent, AfterAutoHandleStateEvent>(OnHandleState);
+
+        SubscribeLocalEvent<ChameleonDisguisedComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<ChameleonDisguisedComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ChameleonDisguisedComponent, GetFlashEffectTargetEvent>(OnGetFlashEffectTargetEvent);
     }
 
     private void OnHandleState(Entity<ChameleonDisguiseComponent> ent, ref AfterAutoHandleStateEvent args)
     {
         CopyComp<SpriteComponent>(ent);
         CopyComp<GenericVisualizerComponent>(ent);
         CopyComp<SolutionContainerVisualsComponent>(ent);
+        CopyComp<BurnStateVisualsComponent>(ent);
 
         // reload appearance to hopefully prevent any invisible layers
         if (_appearanceQuery.TryComp(ent, out var appearance))
             _appearance.QueueUpdate(ent, appearance);
     }
+
+    private void OnStartup(Entity<ChameleonDisguisedComponent> ent, ref ComponentStartup args)
+    {
+        if (!_spriteQuery.TryComp(ent, out var sprite))
+            return;
+
+        ent.Comp.WasVisible = sprite.Visible;
+        sprite.Visible = false;
+    }
+
+    private void OnShutdown(Entity<ChameleonDisguisedComponent> ent, ref ComponentShutdown args)
+    {
+        if (_spriteQuery.TryComp(ent, out var sprite))
+            sprite.Visible = ent.Comp.WasVisible;
+    }
+
+    private void OnGetFlashEffectTargetEvent(Entity<ChameleonDisguisedComponent> ent, ref GetFlashEffectTargetEvent args)
+    {
+        args.Target = ent.Comp.Disguise;
+    }
 }

Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRoleButtonsBox.xaml

@@ -0,0 +1,9 @@
+<BoxContainer xmlns="https://spacestation14.io"
+              Orientation="Vertical"
+              Margin="8 0 8 0">
+    <BoxContainer Name="Buttons"
+                  Orientation="Vertical"
+                  SeparationOverride="5">
+        <!-- Buttons are added here by code -->
+    </BoxContainer>
+</BoxContainer>

Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRolesEntry.xaml.cs → Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRoleButtonsBox.xaml.cs

@@ -10,20 +10,17 @@
 namespace Content.Client.UserInterface.Systems.Ghost.Controls.Roles
 {
     [GenerateTypedNameReferences]
-    public sealed partial class GhostRolesEntry : BoxContainer
+    public sealed partial class GhostRoleButtonsBox : BoxContainer
     {
         private SpriteSystem _spriteSystem;
         public event Action<GhostRoleInfo>? OnRoleSelected;
         public event Action<GhostRoleInfo>? OnRoleFollow;
 
-        public GhostRolesEntry(string name, string description, bool hasAccess, FormattedMessage? reason, IEnumerable<GhostRoleInfo> roles, SpriteSystem spriteSystem)
+        public GhostRoleButtonsBox(bool hasAccess, FormattedMessage? reason, IEnumerable<GhostRoleInfo> roles, SpriteSystem spriteSystem)
         {
             RobustXamlLoader.Load(this);
             _spriteSystem = spriteSystem;
 
-            Title.Text = name;
-            Description.SetMessage(description);
-
             foreach (var role in roles)
             {
                 var button = new GhostRoleEntryButtons(role);

Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRoleEntryButtons.xaml

@@ -1,15 +1,15 @@
 <BoxContainer xmlns="https://spacestation14.io"
-              Orientation="Horizontal">
+              Orientation="Horizontal"
+              HorizontalAlignment="Stretch">
     <Button Name="RequestButton"
             Access="Public"
             Text="{Loc 'ghost-roles-window-request-role-button'}"
             StyleClasses="OpenRight"
-            HorizontalAlignment="Left"
-            SetWidth="300"/>
+            HorizontalExpand="True"
+            SizeFlagsStretchRatio="3"/>
     <Button Name="FollowButton"
             Access="Public"
             Text="{Loc 'ghost-roles-window-follow-role-button'}"
             StyleClasses="OpenLeft"
-            HorizontalAlignment="Right"
-            SetWidth="150"/>
+            HorizontalExpand="True"/>
 </BoxContainer>

Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRoleInfoBox.xaml

@@ -0,0 +1,8 @@
+<BoxContainer xmlns="https://spacestation14.io"
+              Orientation="Vertical">
+    <Label Name="Title"
+           StyleClasses="LabelKeyText"/>
+    <PanelContainer StyleClasses="HighDivider" />
+    <RichTextLabel Name="Description"
+                   Margin="0 4"/>
+</BoxContainer>

Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRoleInfoBox.xaml.cs

@@ -0,0 +1,18 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.UserInterface.Systems.Ghost.Controls.Roles
+{
+    [GenerateTypedNameReferences]
+    public sealed partial class GhostRoleInfoBox : BoxContainer
+    {
+        public GhostRoleInfoBox(string name, string description)
+        {
+            RobustXamlLoader.Load(this);
+
+            Title.Text = name;
+            Description.SetMessage(description);
+        }
+    }
+}

Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRolesEui.cs

@@ -77,20 +77,30 @@ public override void HandleState(EuiStateBase state)
 
             if (state is not GhostRolesEuiState ghostState)
                 return;
+
+            // We must save BodyVisible state, so all Collapsible boxes will not close
+            // on adding new ghost role.
+            // Save the current state of each Collapsible box being visible or not
+            _window.SaveCollapsibleBoxesStates();
+
+            // Clearing the container before adding new roles
             _window.ClearEntries();
 
             var entityManager = IoCManager.Resolve<IEntityManager>();
             var sysManager = entityManager.EntitySysManager;
             var spriteSystem = sysManager.GetEntitySystem<SpriteSystem>();
             var requirementsManager = IoCManager.Resolve<JobRequirementsManager>();
 
+            // TODO: role.Requirements value doesn't work at all as an equality key, this must be fixed
+            // Grouping roles
             var groupedRoles = ghostState.GhostRoles.GroupBy(
                 role => (role.Name, role.Description, role.Requirements, role.WhitelistRequired)); //backmen: whitelist
 
             //start-backmen: whitelist
             var cfg = IoCManager.Resolve<Robust.Shared.Configuration.IConfigurationManager>();
             //end-backmen: whitelist
 
+            // Add a new entry for each role group
             foreach (var group in groupedRoles)
             {
                 var name = group.Key.Name;
@@ -115,14 +125,17 @@ public override void HandleState(EuiStateBase state)
                     hasAccess = false;
                 }
 
+                // Adding a new role
                 _window.AddEntry(name, description, hasAccess, reason, group, spriteSystem);
             }
 
+            // Restore the Collapsible box state if it is saved
+            _window.RestoreCollapsibleBoxesStates();
+
+            // Close the rules window if it is no longer needed
             var closeRulesWindow = ghostState.GhostRoles.All(role => role.Identifier != _windowRulesId);
             if (closeRulesWindow)
-            {
                 _windowRules?.Close();
-            }
         }
     }
 }

Content.Client/UserInterface/Systems/Ghost/Controls/Roles/GhostRolesWindow.xaml.cs

@@ -1,7 +1,10 @@
+using System.Linq;
 using Content.Shared.Ghost.Roles;
 using Robust.Client.AutoGenerated;
 using Robust.Client.GameObjects;
+using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Utility;
 
 // start-backmen: whitelist
@@ -18,20 +21,86 @@ public sealed partial class GhostRolesWindow : DefaultWindow
         public event Action<GhostRoleInfo>? OnRoleRequestButtonClicked;
         public event Action<GhostRoleInfo>? OnRoleFollow;
 
+        private Dictionary<(string name, string description), Collapsible> _collapsibleBoxes = new();
+        private HashSet<(string name, string description)> _uncollapsedStates = new();
+
+        public GhostRolesWindow()
+        {
+            RobustXamlLoader.Load(this);
+        }
+
         public void ClearEntries()
         {
             NoRolesMessage.Visible = true;
             EntryContainer.DisposeAllChildren();
+            _collapsibleBoxes.Clear();
+        }
+
+        public void SaveCollapsibleBoxesStates()
+        {
+            _uncollapsedStates.Clear();
+            foreach (var (key, collapsible) in _collapsibleBoxes)
+            {
+                if (collapsible.BodyVisible)
+                {
+                    _uncollapsedStates.Add(key);
+                }
+            }
+        }
+
+        public void RestoreCollapsibleBoxesStates()
+        {
+            foreach (var (key, collapsible) in _collapsibleBoxes)
+            {
+                collapsible.BodyVisible = _uncollapsedStates.Contains(key);
+            }
         }
 
         public void AddEntry(string name, string description, bool hasAccess, FormattedMessage? reason, IEnumerable<GhostRoleInfo> roles, SpriteSystem spriteSystem)
         {
             NoRolesMessage.Visible = false;
 
-            var entry = new GhostRolesEntry(name, description, hasAccess, reason, roles, spriteSystem);
-            entry.OnRoleSelected += OnRoleRequestButtonClicked;
-            entry.OnRoleFollow += OnRoleFollow;
-            EntryContainer.AddChild(entry);
+            var ghostRoleInfos = roles.ToList();
+            var rolesCount = ghostRoleInfos.Count;
+
+            var info = new GhostRoleInfoBox(name, description);
+            var buttons = new GhostRoleButtonsBox(hasAccess, reason, ghostRoleInfos, spriteSystem);
+            buttons.OnRoleSelected += OnRoleRequestButtonClicked;
+            buttons.OnRoleFollow += OnRoleFollow;
+
+            EntryContainer.AddChild(info);
+
+            if (rolesCount > 1)
+            {
+                var buttonHeading = new CollapsibleHeading(Loc.GetString("ghost-roles-window-available-button", ("rolesCount", rolesCount)));
+
+                buttonHeading.AddStyleClass(ContainerButton.StyleClassButton);
+                buttonHeading.Label.HorizontalAlignment = HAlignment.Center;
+                buttonHeading.Label.HorizontalExpand = true;
+
+                var body = new CollapsibleBody
+                {
+                    Margin = new Thickness(0, 5, 0, 0),
+                };
+
+                // TODO: Add Requirements to this key when it'll be fixed and work as an equality key in GhostRolesEui
+                var key = (name, description);
+
+                var collapsible = new Collapsible(buttonHeading, body)
+                {
+                    Orientation = BoxContainer.LayoutOrientation.Vertical,
+                    Margin = new Thickness(0, 0, 0, 8),
+                };
+
+                body.AddChild(buttons);
+
+                EntryContainer.AddChild(collapsible);
+                _collapsibleBoxes.Add(key, collapsible);
+            }
+            else
+            {
+                EntryContainer.AddChild(buttons);
+            }
         }
 
         // start-backmen: whitelist

Content.Client/Weapons/Ranged/Systems/GunSystem.cs

@@ -160,7 +160,7 @@ public override void Update(float frameTime)
 
         var useKey = gun.UseKey ? EngineKeyFunctions.Use : EngineKeyFunctions.UseSecondary;
 
-        if (_inputSystem.CmdStates.GetState(useKey) != BoundKeyState.Down)
+        if (_inputSystem.CmdStates.GetState(useKey) != BoundKeyState.Down && !gun.BurstActivated)
         {
             if (gun.ShotCounter != 0)
                 EntityManager.RaisePredictiveEvent(new RequestStopShootEvent { Gun = GetNetEntity(gunUid) });