Various Minor Fixes from WizDen / merges up to 20th march

Content.Client/Actions/ActionsSystem.cs

@@ -95,6 +95,7 @@ private void BaseHandleState<T>(EntityUid uid, BaseActionComponent component, Ba
             component.Container = EnsureEntity<T>(state.Container, uid);
             component.EntityIcon = EnsureEntity<T>(state.EntityIcon, uid);
             component.CheckCanInteract = state.CheckCanInteract;
+            component.CheckConsciousness = state.CheckConsciousness;
             component.ClientExclusive = state.ClientExclusive;
             component.Priority = state.Priority;
             component.AttachedEntity = EnsureEntity<T>(state.AttachedEntity, uid);

Content.Client/Alerts/ClientAlertsSystem.cs

@@ -4,6 +4,7 @@
 using Robust.Client.Player;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
 
 namespace Content.Client.Alerts;
 
@@ -12,6 +13,7 @@ public sealed class ClientAlertsSystem : AlertsSystem
 {
     public AlertOrderPrototype? AlertOrder { get; set; }
 
+    [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
 
@@ -49,24 +51,23 @@ public IReadOnlyDictionary<AlertKey, AlertState>? ActiveAlerts
 
     protected override void AfterShowAlert(Entity<AlertsComponent> alerts)
     {
-        if (_playerManager.LocalEntity != alerts.Owner)
-            return;
-
-        SyncAlerts?.Invoke(this, alerts.Comp.Alerts);
+        UpdateHud(alerts);
     }
 
-    protected override void AfterClearAlert(Entity<AlertsComponent> alertsComponent)
+    protected override void AfterClearAlert(Entity<AlertsComponent> alerts)
     {
-        if (_playerManager.LocalEntity != alertsComponent.Owner)
-            return;
+        UpdateHud(alerts);
+    }
 
-        SyncAlerts?.Invoke(this, alertsComponent.Comp.Alerts);
+    private void ClientAlertsHandleState(Entity<AlertsComponent> alerts, ref AfterAutoHandleStateEvent args)
+    {
+        UpdateHud(alerts);
     }
 
-    private void ClientAlertsHandleState(EntityUid uid, AlertsComponent component, ref AfterAutoHandleStateEvent args)
+    private void UpdateHud(Entity<AlertsComponent> entity)
     {
-        if (_playerManager.LocalEntity == uid)
-            SyncAlerts?.Invoke(this, component.Alerts);
+        if (_playerManager.LocalEntity == entity.Owner)
+            SyncAlerts?.Invoke(this, entity.Comp.Alerts);
     }
 
     private void OnPlayerAttached(EntityUid uid, AlertsComponent component, LocalPlayerAttachedEvent args)

Content.Client/Antag/AntagStatusIconSystem.cs

@@ -22,6 +22,7 @@ public override void Initialize()
         SubscribeLocalEvent<RevolutionaryComponent, GetStatusIconsEvent>(GetRevIcon);
         SubscribeLocalEvent<ZombieComponent, GetStatusIconsEvent>(GetIcon);
         SubscribeLocalEvent<HeadRevolutionaryComponent, GetStatusIconsEvent>(GetIcon);
+        SubscribeLocalEvent<InitialInfectedComponent, GetStatusIconsEvent>(GetIcon);
     }
 
     /// <summary>

Content.Client/CardboardBox/CardboardBoxSystem.cs

@@ -1,4 +1,4 @@
-using System.Numerics;
+using System.Numerics;
 using Content.Shared.CardboardBox;
 using Content.Shared.CardboardBox.Components;
 using Content.Shared.Examine;
@@ -11,6 +11,7 @@ public sealed class CardboardBoxSystem : SharedCardboardBoxSystem
 {
     [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
     [Dependency] private readonly TransformSystem _transform = default!;
+    [Dependency] private readonly ExamineSystemShared _examine = default!;
 
     public override void Initialize()
     {
@@ -55,7 +56,7 @@ private void OnBoxEffect(PlayBoxEffectMessage msg)
         foreach (var mob in mobMoverEntities)
         {
             var mapPos = _transform.GetMapCoordinates(mob);
-            if (!ExamineSystemShared.InRangeUnOccluded(sourcePos, mapPos, box.Distance, null))
+            if (!_examine.InRangeUnOccluded(sourcePos, mapPos, box.Distance, null))
                 continue;
 
             var ent = Spawn(box.Effect, mapPos);

Content.Client/Entry/EntryPoint.cs

@@ -70,6 +70,7 @@ public sealed class EntryPoint : GameClient
         [Dependency] private readonly IResourceManager _resourceManager = default!;
         [Dependency] private readonly IReplayLoadManager _replayLoad = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
+        [Dependency] private readonly ContentReplayPlaybackManager _replayMan = default!;
 
         public override void Init()
         {
@@ -100,12 +101,10 @@ public override void Init()
             _prototypeManager.RegisterIgnore("seed"); // Seeds prototypes are server-only.
             _prototypeManager.RegisterIgnore("objective");
             _prototypeManager.RegisterIgnore("holiday");
-            _prototypeManager.RegisterIgnore("aiFaction");
             _prototypeManager.RegisterIgnore("htnCompound");
             _prototypeManager.RegisterIgnore("htnPrimitive");
             _prototypeManager.RegisterIgnore("gameMap");
             _prototypeManager.RegisterIgnore("gameMapPool");
-            _prototypeManager.RegisterIgnore("npcFaction");
             _prototypeManager.RegisterIgnore("lobbyBackground");
             _prototypeManager.RegisterIgnore("advertisementsPack");
             _prototypeManager.RegisterIgnore("gamePreset");
@@ -193,6 +192,7 @@ private void SwitchToDefaultState(bool disconnected = false)
                     _resourceManager,
                     ReplayConstants.ReplayZipFolder.ToRootedPath());
 
+                _replayMan.LastLoad = (null, ReplayConstants.ReplayZipFolder.ToRootedPath());
                 _replayLoad.LoadAndStartReplay(reader);
             }
             else if (_gameController.LaunchState.FromLauncher)

Content.Client/Overlays/ShowHealthIconsSystem.cs

@@ -1,5 +1,7 @@
+using Content.Shared.Atmos.Rotting;
 using Content.Shared.Damage;
 using Content.Shared.Inventory.Events;
+using Content.Shared.Mobs.Components;
 using Content.Shared.Overlays;
 using Content.Shared.StatusIcon;
 using Content.Shared.StatusIcon.Components;
@@ -17,9 +19,6 @@ public sealed class ShowHealthIconsSystem : EquipmentHudSystem<ShowHealthIconsCo
 
     public HashSet<string> DamageContainers = new();
 
-    [ValidatePrototypeId<StatusIconPrototype>]
-    private const string HealthIconFine = "HealthIconFine";
-
     public override void Initialize()
     {
         base.Initialize();
@@ -45,18 +44,20 @@ protected override void DeactivateInternal()
         DamageContainers.Clear();
     }
 
-    private void OnGetStatusIconsEvent(EntityUid uid, DamageableComponent damageableComponent, ref GetStatusIconsEvent args)
+    private void OnGetStatusIconsEvent(Entity<DamageableComponent> entity, ref GetStatusIconsEvent args)
     {
         if (!IsActive || args.InContainer)
             return;
 
-        var healthIcons = DecideHealthIcons(damageableComponent);
+        var healthIcons = DecideHealthIcons(entity);
 
         args.StatusIcons.AddRange(healthIcons);
     }
 
-    private IReadOnlyList<StatusIconPrototype> DecideHealthIcons(DamageableComponent damageableComponent)
+    private IReadOnlyList<StatusIconPrototype> DecideHealthIcons(Entity<DamageableComponent> entity)
     {
+        var damageableComponent = entity.Comp;
+
         if (damageableComponent.DamageContainerID == null ||
             !DamageContainers.Contains(damageableComponent.DamageContainerID))
         {
@@ -66,10 +67,16 @@ private IReadOnlyList<StatusIconPrototype> DecideHealthIcons(DamageableComponent
         var result = new List<StatusIconPrototype>();
 
         // Here you could check health status, diseases, mind status, etc. and pick a good icon, or multiple depending on whatever.
-        if (damageableComponent?.DamageContainerID == "Biological" &&
-            _prototypeMan.TryIndex<StatusIconPrototype>(HealthIconFine, out var healthyIcon))
+        if (damageableComponent?.DamageContainerID == "Biological")
         {
-            result.Add(healthyIcon);
+            if (TryComp<MobStateComponent>(entity, out var state))
+            {
+                // Since there is no MobState for a rotting mob, we have to deal with this case first.
+                if (HasComp<RottingComponent>(entity) && _prototypeMan.TryIndex(damageableComponent.RottingIcon, out var rottingIcon))
+                    result.Add(rottingIcon);
+                else if (damageableComponent.HealthIcons.TryGetValue(state.CurrentState, out var value) && _prototypeMan.TryIndex(value, out var icon))
+                    result.Add(icon);
+            }
         }
 
         return result;

Content.Client/Paint/PaintVisualizerSystem.cs

@@ -0,0 +1,116 @@
+using System.Linq;
+using Robust.Client.GameObjects;
+using static Robust.Client.GameObjects.SpriteComponent;
+using Content.Shared.Clothing;
+using Content.Shared.Hands;
+using Content.Shared.Paint;
+using Robust.Client.Graphics;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Paint;
+
+public sealed class PaintedVisualizerSystem : VisualizerSystem<PaintedComponent>
+{
+    /// <summary>
+    /// Visualizer for Paint which applies a shader and colors the entity.
+    /// </summary>
+
+    [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+    [Dependency] private readonly IPrototypeManager _protoMan = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<PaintedComponent, HeldVisualsUpdatedEvent>(OnHeldVisualsUpdated);
+        SubscribeLocalEvent<PaintedComponent, ComponentShutdown>(OnShutdown);
+        SubscribeLocalEvent<PaintedComponent, EquipmentVisualsUpdatedEvent>(OnEquipmentVisualsUpdated);
+    }
+
+    protected override void OnAppearanceChange(EntityUid uid, PaintedComponent component, ref AppearanceChangeEvent args)
+    {
+        var shader = _protoMan.Index<ShaderPrototype>(component.ShaderName).Instance();
+
+        if (args.Sprite == null)
+            return;
+
+        // What is this even doing? It's not even checking what the value is.
+        if (!_appearance.TryGetData(uid, PaintVisuals.Painted, out bool isPainted))
+            return;
+
+        var sprite = args.Sprite;
+
+        foreach (var spriteLayer in sprite.AllLayers)
+        {
+            if (spriteLayer is not Layer layer)
+                continue;
+
+            if (layer.Shader == null) // If shader isn't null we dont want to replace the original shader.
+            {
+                layer.Shader = shader;
+                layer.Color = component.Color;
+            }
+        }
+    }
+
+    private void OnHeldVisualsUpdated(EntityUid uid, PaintedComponent component, HeldVisualsUpdatedEvent args)
+    {
+        if (args.RevealedLayers.Count == 0)
+            return;
+
+        if (!TryComp(args.User, out SpriteComponent? sprite))
+            return;
+
+        foreach (var revealed in args.RevealedLayers)
+        {
+            if (!sprite.LayerMapTryGet(revealed, out var layer))
+                continue;
+
+            sprite.LayerSetShader(layer, component.ShaderName);
+            sprite.LayerSetColor(layer, component.Color);
+        }
+    }
+
+    private void OnEquipmentVisualsUpdated(EntityUid uid, PaintedComponent component, EquipmentVisualsUpdatedEvent args)
+    {
+        if (args.RevealedLayers.Count == 0)
+            return;
+
+        if (!TryComp(args.Equipee, out SpriteComponent? sprite))
+            return;
+
+        foreach (var revealed in args.RevealedLayers)
+        {
+            if (!sprite.LayerMapTryGet(revealed, out var layer))
+                continue;
+
+            sprite.LayerSetShader(layer, component.ShaderName);
+            sprite.LayerSetColor(layer, component.Color);
+        }
+    }
+
+    private void OnShutdown(EntityUid uid, PaintedComponent component, ref ComponentShutdown args)
+    {
+        if (!TryComp(uid, out SpriteComponent? sprite))
+            return;
+
+        component.BeforeColor = sprite.Color;
+        var shader = _protoMan.Index<ShaderPrototype>(component.ShaderName).Instance();
+
+        if (!Terminating(uid))
+        {
+            foreach (var spriteLayer in sprite.AllLayers)
+            {
+                if (spriteLayer is not Layer layer)
+                    continue;
+
+                if (layer.Shader == shader) // If shader isn't same as one in component we need to ignore it.
+                {
+                    layer.Shader = null;
+                    if (layer.Color == component.Color) // If color isn't the same as one in component we don't want to change it.
+                        layer.Color = component.BeforeColor;
+                }
+            }
+        }
+    }
+}

Content.Client/Physics/Controllers/MoverController.cs

@@ -1,6 +1,7 @@
 using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Pulling.Components;
 using Content.Shared.Movement.Systems;
-using Content.Shared.Pulling.Components;
+using Robust.Client.GameObjects;
 using Robust.Client.Physics;
 using Robust.Client.Player;
 using Robust.Shared.Physics.Components;
@@ -24,7 +25,7 @@ public override void Initialize()
 
             SubscribeLocalEvent<InputMoverComponent, UpdateIsPredictedEvent>(OnUpdatePredicted);
             SubscribeLocalEvent<MovementRelayTargetComponent, UpdateIsPredictedEvent>(OnUpdateRelayTargetPredicted);
-            SubscribeLocalEvent<SharedPullableComponent, UpdateIsPredictedEvent>(OnUpdatePullablePredicted);
+            SubscribeLocalEvent<PullableComponent, UpdateIsPredictedEvent>(OnUpdatePullablePredicted);
         }
 
         private void OnUpdatePredicted(EntityUid uid, InputMoverComponent component, ref UpdateIsPredictedEvent args)
@@ -40,7 +41,7 @@ private void OnUpdateRelayTargetPredicted(EntityUid uid, MovementRelayTargetComp
                 args.IsPredicted = true;
         }
 
-        private void OnUpdatePullablePredicted(EntityUid uid, SharedPullableComponent component, ref UpdateIsPredictedEvent args)
+        private void OnUpdatePullablePredicted(EntityUid uid, PullableComponent component, ref UpdateIsPredictedEvent args)
         {
             // Enable prediction if an entity is being pulled by the player.
             // Disable prediction if an entity is being pulled by some non-player entity.

Content.Client/Popups/PopupOverlay.cs

@@ -21,6 +21,7 @@ public sealed class PopupOverlay : Overlay
     private readonly IUserInterfaceManager _uiManager;
     private readonly PopupSystem _popup;
     private readonly PopupUIController _controller;
+    private readonly ExamineSystemShared _examine;
 
     private readonly ShaderInstance _shader;
 
@@ -33,12 +34,14 @@ public PopupOverlay(
         IPrototypeManager protoManager,
         IUserInterfaceManager uiManager,
         PopupUIController controller,
+        ExamineSystemShared examine,
         PopupSystem popup)
     {
         _configManager = configManager;
         _entManager = entManager;
         _playerMgr = playerMgr;
         _uiManager = uiManager;
+        _examine = examine;
         _popup = popup;
         _controller = controller;
 
@@ -81,7 +84,7 @@ private void DrawWorld(DrawingHandleScreen worldHandle, OverlayDrawArgs args, fl
             var distance = (mapPos.Position - args.WorldBounds.Center).Length();
 
             // Should handle fade here too wyci.
-            if (!args.WorldBounds.Contains(mapPos.Position) || !ExamineSystemShared.InRangeUnOccluded(viewPos, mapPos, distance,
+            if (!args.WorldBounds.Contains(mapPos.Position) || !_examine.InRangeUnOccluded(viewPos, mapPos, distance,
                     e => e == popup.InitialPos.EntityId || e == ourEntity, entMan: _entManager))
                 continue;
 

Content.Client/Popups/PopupSystem.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using Content.Shared.Examine;
 using Content.Shared.GameTicking;
 using Content.Shared.Popups;
 using Robust.Client.Graphics;
@@ -26,6 +27,7 @@ public sealed class PopupSystem : SharedPopupSystem
         [Dependency] private readonly IGameTiming _timing = default!;
         [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
         [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
+        [Dependency] private readonly ExamineSystemShared _examine = default!;
 
         public IReadOnlyList<WorldPopupLabel> WorldLabels => _aliveWorldLabels;
         public IReadOnlyList<CursorPopupLabel> CursorLabels => _aliveCursorLabels;
@@ -51,6 +53,7 @@ public override void Initialize()
                     _prototype,
                     _uiManager,
                     _uiManager.GetUIController<PopupUIController>(),
+                    _examine,
                     this));
         }