Added ClothingLimitVision Component

Content.Client/Content.Client.csproj

@@ -24,7 +24,9 @@
     <ProjectReference Include="..\Content.Shared\Content.Shared.csproj" />
   </ItemGroup>
   <ItemGroup>
+    <Folder Include="Clothing\Components\" />
     <Folder Include="Spawners\" />
+    <Folder Include="_White\VisionLimit\Overlays\System\" />
   </ItemGroup>
   <ItemGroup>
     <Compile Update="Lobby\UI\LobbyCharacterPanel.xaml.cs">

Content.Client/_White/VisionLimit/Overlays/VisionLimitOverlay.cs

@@ -0,0 +1,53 @@
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._White.VisionLimit.Overlays
+
+{
+    public sealed class VisionLimitOverlay : Overlay
+    {
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
+        public float VisionLimitRadius;
+
+        public override bool RequestScreenTexture => true;
+        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+        private readonly ShaderInstance _circleMaskShader;
+
+        public VisionLimitOverlay()
+        {
+            IoCManager.InjectDependencies(this);
+            _circleMaskShader = _prototypeManager.Index<ShaderPrototype>("CircleMask").InstanceUnique();
+        }
+
+        protected override void Draw(in OverlayDrawArgs args)
+        {
+            if (ScreenTexture == null)
+                return;
+
+            var playerEntity = _playerManager.LocalSession?.AttachedEntity;
+
+            if (playerEntity == null)
+                return;
+
+            if (_entityManager.TryGetComponent<EyeComponent>(playerEntity, out var content))
+            {
+                _circleMaskShader.SetParameter("Zoom", content.Zoom.X);
+
+                _circleMaskShader.SetParameter("CircleRadius", 6.5f); // It's relative, close enough to
+                _circleMaskShader.SetParameter("CircleMinDist", VisionLimitRadius * 10); // 1 unit = 1 tile
+            }
+
+            var worldHandle = args.WorldHandle;
+            var viewport = args.WorldBounds;
+
+            worldHandle.UseShader(_circleMaskShader);
+            worldHandle.DrawRect(viewport, Color.White);
+            worldHandle.UseShader(null);
+        }
+    }
+}

Content.Client/_White/VisionLimit/Systems/VisionLimitSystem.cs

@@ -0,0 +1,126 @@
+using Content.Client._White.VisionLimit.Overlays;
+using Content.Shared._White.VisionLimit.Components;
+using Content.Shared.Clothing;
+using Content.Shared.Inventory.Events;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Player;
+
+namespace Content.Client._White.VisionLimit.Systems;
+
+public sealed class VisionLimitSystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+
+    private VisionLimitOverlay _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<VisionLimitComponent, ComponentInit>(OnCompInit);
+        SubscribeLocalEvent<VisionLimitComponent, ComponentShutdown>(OnCompShutdown);
+
+        SubscribeLocalEvent<VisionLimitComponent, LocalPlayerAttachedEvent>(OnPlayerAttached);
+        SubscribeLocalEvent<VisionLimitComponent, LocalPlayerDetachedEvent>(OnPlayerDetached);
+
+        SubscribeLocalEvent<ClothingLimitVisionComponent, GotEquippedEvent>(OnGotEquipped);
+        SubscribeLocalEvent<ClothingLimitVisionComponent, GotUnequippedEvent>(OnGotUnequipped);
+        SubscribeLocalEvent<ClothingLimitVisionComponent, ItemMaskToggledEvent>(OnMaskToggled);
+
+        _overlay = new();
+        _overlay.ZIndex = -2; // Draw under damage overlay etc.
+    }
+
+    // Player entity interactions
+
+    private void OnPlayerAttached(EntityUid uid, VisionLimitComponent component, LocalPlayerAttachedEvent args)
+    {
+        UpdateOverlay(component);
+    }
+
+    private void OnPlayerDetached(EntityUid uid, VisionLimitComponent component, LocalPlayerDetachedEvent args)
+    {
+        _overlayMan.RemoveOverlay(_overlay);
+    }
+
+    private void OnCompInit(EntityUid uid, VisionLimitComponent component, ComponentInit args)
+    {
+        if (_player.LocalEntity == uid)
+            UpdateOverlay(component);
+    }
+
+    private void OnCompShutdown(EntityUid uid, VisionLimitComponent component, ComponentShutdown args)
+    {
+        if (_player.LocalEntity == uid)
+        {
+            _overlayMan.RemoveOverlay(_overlay);
+        }
+    }
+
+    // Equipment interactions
+
+    private void OnGotEquipped(EntityUid uid, ClothingLimitVisionComponent comp, GotEquippedEvent args)
+    {
+        AddLimit(args.Equipee, comp);
+    }
+
+    private void OnGotUnequipped(EntityUid uid, ClothingLimitVisionComponent comp, GotUnequippedEvent args)
+    {
+        RemoveLimit(args.Equipee, comp);
+    }
+
+    private void OnMaskToggled(EntityUid uid, ClothingLimitVisionComponent comp, ItemMaskToggledEvent args)
+    {
+        if (!args.IsToggled && !args.IsEquip)
+            AddLimit(args.Wearer, comp);
+        else
+            RemoveLimit(args.Wearer, comp);
+    }
+
+    // Overlay handling
+
+    private void AddLimit(EntityUid uid, ClothingLimitVisionComponent limiter)
+    {
+        if (limiter.Radius == 0) // Radius 0 = no limit
+            return;
+
+        EnsureComp<VisionLimitComponent>(uid, out var comp);
+        comp.VisionLimiters.Add(limiter, limiter.Radius);
+        UpdateOverlay(comp);
+    }
+
+    private void RemoveLimit(EntityUid uid, ClothingLimitVisionComponent limiter)
+    {
+        if (TryComp<VisionLimitComponent>(uid, out var comp) && comp.VisionLimiters.ContainsKey(limiter))
+        {
+            comp.VisionLimiters.Remove(limiter);
+            UpdateOverlay(comp);
+
+            if (comp.VisionLimiters.Count == 0)
+                RemComp<VisionLimitComponent>(uid);
+        }
+
+    }
+
+    private void UpdateOverlay(VisionLimitComponent comp)
+    {
+        if (comp.VisionLimiters.Count > 0)
+        {
+            // Assign the smallest radius value from the VisionLimiters to the overlay
+            var min = 1337f;
+
+            foreach (var limiter in comp.VisionLimiters)
+            {
+                if (limiter.Value < min)
+                    min = limiter.Value;
+            }
+            _overlay.VisionLimitRadius = min;
+
+            _overlayMan.AddOverlay(_overlay);
+        }
+        else
+            _overlayMan.RemoveOverlay(_overlay);
+    }
+}

Content.Shared/Clothing/EntitySystems/MaskSystem.cs

@@ -35,38 +35,40 @@ private void OnGetActions(EntityUid uid, MaskComponent component, GetItemActions
     private void OnToggleMask(Entity<MaskComponent> ent, ref ToggleMaskEvent args)
     {
         var (uid, mask) = ent;
-        if (mask.ToggleActionEntity == null || !_timing.IsFirstTimePredicted)
+        if (!_timing.IsFirstTimePredicted)
             return;
 
         if (!_inventorySystem.TryGetSlotEntity(args.Performer, "mask", out var existing) || !uid.Equals(existing))
             return;
 
         mask.IsToggled ^= true;
-        _actionSystem.SetToggled(mask.ToggleActionEntity, mask.IsToggled);
 
-        if (mask.IsToggled)
-            _popupSystem.PopupEntity(Loc.GetString("action-mask-pull-down-popup-message", ("mask", uid)), args.Performer, args.Performer);
-        else
-            _popupSystem.PopupEntity(Loc.GetString("action-mask-pull-up-popup-message", ("mask", uid)), args.Performer, args.Performer);
+        var dir = mask.IsToggled ? "down" : "up";
+        var msg = $"action-mask-pull-{dir}-popup-message";
+        _popupSystem.PopupClient(Loc.GetString(msg, ("mask", uid)), args.Performer, args.Performer);
 
         ToggleMaskComponents(uid, mask, args.Performer, mask.EquippedPrefix);
     }
 
     // set to untoggled when unequipped, so it isn't left in a 'pulled down' state
     private void OnGotUnequipped(EntityUid uid, MaskComponent mask, GotUnequippedEvent args)
     {
-        if (mask.ToggleActionEntity == null)
+        if (!mask.IsToggled)
             return;
 
         mask.IsToggled = false;
-        Dirty(uid, mask);
-        _actionSystem.SetToggled(mask.ToggleActionEntity, mask.IsToggled);
-
         ToggleMaskComponents(uid, mask, args.Equipee, mask.EquippedPrefix, true);
     }
 
+    /// <summary>
+    /// Called after setting IsToggled, raises events and dirties.
+    /// <summary>
     private void ToggleMaskComponents(EntityUid uid, MaskComponent mask, EntityUid wearer, string? equippedPrefix = null, bool isEquip = false)
     {
+        Dirty(uid, mask);
+        if (mask.ToggleActionEntity is {} action)
+            _actionSystem.SetToggled(action, mask.IsToggled);
+
         var maskEv = new ItemMaskToggledEvent(wearer, equippedPrefix, mask.IsToggled, isEquip);
         RaiseLocalEvent(uid, ref maskEv);
 

Content.Shared/Content.Shared.csproj

@@ -16,6 +16,7 @@
     <ProjectReference Include="..\RobustToolbox\Lidgren.Network\Lidgren.Network.csproj">
       <Private>false</Private>
     </ProjectReference>
+    <ProjectReference Include="..\RobustToolbox\Robust.Client\Robust.Client.csproj" />
     <ProjectReference Include="..\RobustToolbox\Robust.Shared.Maths\Robust.Shared.Maths.csproj">
       <Private>false</Private>
     </ProjectReference>
@@ -25,6 +26,7 @@
   </ItemGroup>
   <ItemGroup>
     <Folder Include="DeltaV\Abilities\" />
+    <Folder Include="_White\VisionLimit\" />
   </ItemGroup>
   <Import Project="..\RobustToolbox\MSBuild\Robust.Properties.targets" />
   <Import Project="..\RobustToolbox\MSBuild\Robust.CompNetworkGenerator.targets" />

Content.Shared/_White/VisionLimit/Components/ClothingLimitVisionComponent.cs

@@ -0,0 +1,13 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared._White.VisionLimit.Components;
+
+[NetworkedComponent, RegisterComponent, AutoGenerateComponentState]
+public sealed partial class ClothingLimitVisionComponent: Component
+{
+    /// <summary>
+    /// Limits wearer's vision to roughly Radius tiles
+    /// </summary>
+    [DataField, ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public float Radius; // in tiles, 0 = no limit
+}

Content.Shared/_White/VisionLimit/Components/VisionLimitComponent.cs

@@ -0,0 +1,13 @@
+namespace Content.Shared._White.VisionLimit.Components;
+
+[RegisterComponent]
+public sealed partial class VisionLimitComponent: Component
+{
+    /// <summary>
+    /// Stores values of limits applied to an entity by any VisionLimiterComponent
+    /// </summary>
+
+    [DataField]
+    public Dictionary<ClothingLimitVisionComponent, float> VisionLimiters { get; set; } = new();
+
+}

Resources/Prototypes/Entities/Clothing/Head/welding.yml

@@ -7,6 +7,9 @@
   - type: Item
     storedRotation: 0
   - type: IngestionBlocker
+  - type: Mask
+  - type: ClothingLimitVision
+    radius: 6
   - type: FlashImmunity
   - type: IdentityBlocker
   - type: EyeProtection