EE Merge + Station AI

Content.Client/Administration/UI/BanPanel/BanPanel.xaml.cs

@@ -147,7 +147,7 @@ public BanPanel()
         var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
         foreach (var proto in prototypeManager.EnumeratePrototypes<DepartmentPrototype>())
         {
-            CreateRoleGroup(proto.ID, proto.Roles, proto.Color);
+            CreateRoleGroup(proto.ID, proto.Roles.Select(p =>  p.Id), proto.Color);
         }
 
         CreateRoleGroup("Antagonist", prototypeManager.EnumeratePrototypes<AntagPrototype>().Select(p => p.ID), Color.Red);

Content.Client/Chat/UI/EmotesMenu.xaml.cs

@@ -19,18 +19,15 @@ public sealed partial class EmotesMenu : RadialMenu
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly ISharedPlayerManager _playerManager = default!;
 
-    private readonly SpriteSystem _spriteSystem;
-    private readonly EntityWhitelistSystem _whitelistSystem;
-
     public event Action<ProtoId<EmotePrototype>>? OnPlayEmote;
 
     public EmotesMenu()
     {
         IoCManager.InjectDependencies(this);
         RobustXamlLoader.Load(this);
 
-        _spriteSystem = _entManager.System<SpriteSystem>();
-        _whitelistSystem = _entManager.System<EntityWhitelistSystem>();
+        var spriteSystem = _entManager.System<SpriteSystem>();
+        var whitelistSystem = _entManager.System<EntityWhitelistSystem>();
 
         var main = FindControl<RadialContainer>("Main");
 
@@ -40,8 +37,8 @@ public EmotesMenu()
             var player = _playerManager.LocalSession?.AttachedEntity;
             if (emote.Category == EmoteCategory.Invalid ||
                 emote.ChatTriggers.Count == 0 ||
-                !(player.HasValue && _whitelistSystem.IsWhitelistPassOrNull(emote.Whitelist, player.Value)) ||
-                _whitelistSystem.IsBlacklistPass(emote.Blacklist, player.Value))
+                !(player.HasValue && whitelistSystem.IsWhitelistPassOrNull(emote.Whitelist, player.Value)) ||
+                whitelistSystem.IsBlacklistPass(emote.Blacklist, player.Value))
                 continue;
 
             if (!emote.Available &&
@@ -63,7 +60,7 @@ public EmotesMenu()
             {
                 VerticalAlignment = VAlignment.Center,
                 HorizontalAlignment = HAlignment.Center,
-                Texture = _spriteSystem.Frame0(emote.Icon),
+                Texture = spriteSystem.Frame0(emote.Icon),
                 TextureScale = new Vector2(2f, 2f),
             };
 

Content.Client/Commands/SetMenuVisibilityCommand.cs

@@ -1,4 +1,5 @@
 using Content.Client.Verbs;
+using Content.Shared.Verbs;
 using JetBrains.Annotations;
 using Robust.Shared.Console;
 

Content.Client/ContextMenu/UI/EntityMenuUIController.cs

@@ -9,6 +9,7 @@
 using Content.Shared.Examine;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Input;
+using Content.Shared.Verbs;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
@@ -194,8 +195,20 @@ public override void FrameUpdate(FrameEventArgs args)
                 return;
 
             // Do we need to do in-range unOccluded checks?
-            var ignoreFov = !_eyeManager.CurrentEye.DrawFov ||
-                (_verbSystem.Visibility & MenuVisibility.NoFov) == MenuVisibility.NoFov;
+            var visibility = _verbSystem.Visibility;
+
+            if (!_eyeManager.CurrentEye.DrawFov)
+            {
+                visibility &= ~MenuVisibility.NoFov;
+            }
+
+            var ev = new MenuVisibilityEvent()
+            {
+                Visibility = visibility,
+            };
+
+            _entityManager.EventBus.RaiseLocalEvent(player, ref ev);
+            visibility = ev.Visibility;
 
             _entityManager.TryGetComponent(player, out ExaminerComponent? examiner);
             var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
@@ -209,7 +222,7 @@ public override void FrameUpdate(FrameEventArgs args)
                     continue;
                 }
 
-                if (ignoreFov)
+                if ((visibility & MenuVisibility.NoFov) == MenuVisibility.NoFov)
                     continue;
 
                 var pos = new MapCoordinates(_xform.GetWorldPosition(xform, xformQuery), xform.MapID);

Content.Client/Electrocution/ElectrocutionHUDVisualizerSystem.cs

@@ -0,0 +1,95 @@
+using Content.Shared.Electrocution;
+using Robust.Client.GameObjects;
+using Robust.Client.Player;
+using Robust.Shared.Player;
+
+namespace Content.Client.Electrocution;
+
+/// <summary>
+/// Shows the Electrocution HUD to entities with the ShowElectrocutionHUDComponent.
+/// </summary>
+public sealed class ElectrocutionHUDVisualizerSystem : VisualizerSystem<ElectrocutionHUDVisualsComponent>
+{
+    [Dependency] private readonly IPlayerManager _playerMan = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ShowElectrocutionHUDComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<ShowElectrocutionHUDComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<ShowElectrocutionHUDComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<ShowElectrocutionHUDComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
+    }
+
+    private void OnPlayerAttached(Entity<ShowElectrocutionHUDComponent> ent, ref LocalPlayerAttachedEvent args)
+    {
+        ShowHUD();
+    }
+
+    private void OnPlayerDetached(Entity<ShowElectrocutionHUDComponent> ent, ref LocalPlayerDetachedEvent args)
+    {
+        RemoveHUD();
+    }
+
+    private void OnInit(Entity<ShowElectrocutionHUDComponent> ent, ref ComponentInit args)
+    {
+        if (_playerMan.LocalEntity == ent)
+        {
+            ShowHUD();
+        }
+    }
+
+    private void OnShutdown(Entity<ShowElectrocutionHUDComponent> ent, ref ComponentShutdown args)
+    {
+        if (_playerMan.LocalEntity == ent)
+        {
+            RemoveHUD();
+        }
+    }
+
+    // Show the HUD to the client.
+    // We have to look for all current entities that can be electrified and toggle the HUD layer on if they are.
+    private void ShowHUD()
+    {
+        var electrifiedQuery = AllEntityQuery<ElectrocutionHUDVisualsComponent, AppearanceComponent, SpriteComponent>();
+        while (electrifiedQuery.MoveNext(out var uid, out var _, out var appearanceComp, out var spriteComp))
+        {
+            if (!AppearanceSystem.TryGetData<bool>(uid, ElectrifiedVisuals.IsElectrified, out var electrified, appearanceComp))
+                continue;
+
+            if (electrified)
+                spriteComp.LayerSetVisible(ElectrifiedLayers.HUD, true);
+            else
+                spriteComp.LayerSetVisible(ElectrifiedLayers.HUD, false);
+        }
+    }
+
+    // Remove the HUD from the client.
+    // Find all current entities that can be electrified and hide the HUD layer.
+    private void RemoveHUD()
+    {
+        var electrifiedQuery = AllEntityQuery<ElectrocutionHUDVisualsComponent, AppearanceComponent, SpriteComponent>();
+        while (electrifiedQuery.MoveNext(out var uid, out var _, out var appearanceComp, out var spriteComp))
+        {
+
+            spriteComp.LayerSetVisible(ElectrifiedLayers.HUD, false);
+        }
+    }
+
+    // Toggle the HUD layer if an entity becomes (de-)electrified
+    protected override void OnAppearanceChange(EntityUid uid, ElectrocutionHUDVisualsComponent comp, ref AppearanceChangeEvent args)
+    {
+        if (args.Sprite == null)
+            return;
+
+        if (!AppearanceSystem.TryGetData<bool>(uid, ElectrifiedVisuals.IsElectrified, out var electrified, args.Component))
+            return;
+
+        var player = _playerMan.LocalEntity;
+        if (electrified && HasComp<ShowElectrocutionHUDComponent>(player))
+            args.Sprite.LayerSetVisible(ElectrifiedLayers.HUD, true);
+        else
+            args.Sprite.LayerSetVisible(ElectrifiedLayers.HUD, false);
+    }
+}

Content.Client/Interaction/DragDropSystem.cs

@@ -495,7 +495,7 @@ private void RemoveHighlights()
         // CanInteract() doesn't support checking a second "target" entity.
         // Doing so manually:
         var ev = new GettingInteractedWithAttemptEvent(user, dragged);
-        RaiseLocalEvent(dragged, ev, true);
+        RaiseLocalEvent(dragged, ref ev);
 
         if (ev.Cancelled)
             return false;

Content.Client/Lobby/UI/HumanoidProfileEditor.xaml.cs

@@ -707,8 +707,17 @@ public void RefreshJobs()
             _jobPriorities.Clear();
             var firstCategory = true;
 
-            var departments = _prototypeManager.EnumeratePrototypes<DepartmentPrototype>().ToArray();
-            Array.Sort(departments, DepartmentUIComparer.Instance);
+            // Get all displayed departments
+            var departments = new List<DepartmentPrototype>();
+            foreach (var department in _prototypeManager.EnumeratePrototypes<DepartmentPrototype>())
+            {
+                if (department.EditorHidden)
+                    continue;
+
+                departments.Add(department);
+            }
+
+            departments.Sort(DepartmentUIComparer.Instance);
 
             var items = new[]
             {
@@ -886,7 +895,7 @@ private void UpdateRoleRequirements()
                     JobList.AddChild(category);
                 }
 
-                var jobs = department.Roles.Select(jobId => _prototypeManager.Index<JobPrototype>(jobId))
+                var jobs = department.Roles.Select(jobId => _prototypeManager.Index(jobId))
                     .Where(job => job.SetPreference)
                     .ToArray();
                 Array.Sort(jobs, JobUIComparer.Instance);

Content.Client/Overlays/EquipmentHudSystem.cs

@@ -102,7 +102,7 @@ protected virtual void OnRefreshComponentHud(EntityUid uid, T component, Refresh
         args.Components.Add(component);
     }
 
-    private void RefreshOverlay(EntityUid uid)
+    protected void RefreshOverlay(EntityUid uid)
     {
         if (uid != _player.LocalSession?.AttachedEntity)
             return;

Content.Client/Overlays/Switchable/BaseSwitchableOverlay.cs

@@ -0,0 +1,48 @@
+using System.Numerics;
+using Content.Shared.Overlays.Switchable;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Overlays.Switchable;
+
+public sealed class BaseSwitchableOverlay<TComp> : Overlay where TComp : SwitchableOverlayComponent
+{
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+
+    public override bool RequestScreenTexture => true;
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+    private readonly ShaderInstance _shader;
+
+    public TComp? Comp = null;
+
+    public bool IsActive = true;
+
+    public BaseSwitchableOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _shader = _prototype.Index<ShaderPrototype>("NightVision").InstanceUnique();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (ScreenTexture is null || Comp is null || !IsActive)
+            return;
+
+        _shader.SetParameter("SCREEN_TEXTURE", ScreenTexture);
+        _shader.SetParameter("tint", Comp.Tint);
+        _shader.SetParameter("luminance_threshold", Comp.Strength);
+        _shader.SetParameter("noise_amount", Comp.Noise);
+
+        var worldHandle = args.WorldHandle;
+
+        var accumulator = Math.Clamp(Comp.PulseAccumulator, 0f, Comp.PulseTime);
+        var alpha = Comp.PulseTime <= 0f ? 1f : float.Lerp(1f, 0f, accumulator / Comp.PulseTime);
+
+        worldHandle.SetTransform(Matrix3x2.Identity);
+        worldHandle.UseShader(_shader);
+        worldHandle.DrawRect(args.WorldBounds, Comp.Color.WithAlpha(alpha));
+        worldHandle.UseShader(null);
+    }
+}

Content.Client/Overlays/Switchable/NightVisionSystem.cs

@@ -0,0 +1,87 @@
+using Content.Shared.Inventory.Events;
+using Content.Shared.Overlays.Switchable;
+using Robust.Client.Graphics;
+
+namespace Content.Client.Overlays.Switchable;
+
+public sealed class NightVisionSystem : EquipmentHudSystem<NightVisionComponent>
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+    [Dependency] private readonly ILightManager _lightManager = default!;
+
+    private BaseSwitchableOverlay<NightVisionComponent> _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<NightVisionComponent, SwitchableOverlayToggledEvent>(OnToggle);
+
+        _overlay = new BaseSwitchableOverlay<NightVisionComponent>();
+    }
+
+    private void OnToggle(Entity<NightVisionComponent> ent, ref SwitchableOverlayToggledEvent args)
+    {
+        RefreshOverlay(args.User);
+    }
+
+    protected override void UpdateInternal(RefreshEquipmentHudEvent<NightVisionComponent> args)
+    {
+        base.UpdateInternal(args);
+
+        var active = false;
+        NightVisionComponent? nvComp = null;
+        foreach (var comp in args.Components)
+        {
+            if (comp.IsActive || comp.PulseTime > 0f && comp.PulseAccumulator < comp.PulseTime)
+                active = true;
+            else
+                continue;
+
+            if (comp.DrawOverlay)
+            {
+                if (nvComp == null)
+                    nvComp = comp;
+                else if (nvComp.PulseTime > 0f && comp.PulseTime <= 0f)
+                    nvComp = comp;
+            }
+
+            if (active && nvComp is { PulseTime: <= 0 })
+                break;
+        }
+
+        UpdateNightVision(active);
+        UpdateOverlay(nvComp);
+    }
+
+    protected override void DeactivateInternal()
+    {
+        base.DeactivateInternal();
+
+        UpdateNightVision(false);
+        UpdateOverlay(null);
+    }
+
+    private void UpdateNightVision(bool active)
+    {
+        _lightManager.DrawLighting = !active;
+    }
+
+    private void UpdateOverlay(NightVisionComponent? nvComp)
+    {
+        _overlay.Comp = nvComp;
+
+        switch (nvComp)
+        {
+            case not null when !_overlayMan.HasOverlay<BaseSwitchableOverlay<NightVisionComponent>>():
+                _overlayMan.AddOverlay(_overlay);
+                break;
+            case null:
+                _overlayMan.RemoveOverlay(_overlay);
+                break;
+        }
+
+        if (_overlayMan.TryGetOverlay<BaseSwitchableOverlay<ThermalVisionComponent>>(out var overlay))
+            overlay.IsActive = nvComp == null;
+    }
+}