Add health bar overlays for eye equipment (#21980)

* PR 1 * fix an error with health bar overlay (#1292) * Revert "Revert "Replace `ResourcePath` with `ResPath` (#15308)" (#155… (#15566) * [1612] change ShowHealthBarsComponent's DamageContainer field to a list (#1662) * fix build * no crit entities from not updating * cleanup * namespace * undu irrelevant changes * undo icon change * make health bar 1 px taller and icon 1 px shorter * fix medibot * fix comment * don't show health bar ratio when in crit * fix build * put the crit bar back * don't render healthbars for mobs that are in containers * draw more boxes without the background sprite * fine status icon for all bio mobs * add wacky mandatory things * attempt 2 * whoops wrong file * cool, this works too * move null check to top * only 1 init * security huds * remove shader * fix build after cleanup * slight cleanup * little more cleanup * Remove clothing grant component system * security HUD now shows a job icon on entities with a body * remove sec stuff and do similar changes to split off PR + remove unused comp * process comments * don't return * update to ComponentAddedOverlaySystemBase * no cache * colors and not rendering out of sight * touch ups * fix build & cleanup * undo * remove shader from icons * process comments * documentation * fix licence * validate prototype id * just use args * rename method and append in method * type * just fucken delete the command * space * undo * remove * don't use LocalPlayer * re-add showhealthbars command, but working * rename icon lists and conform health icon code to the others * space * undo * update command * oops --------- Co-authored-by: Rane <60792108+Elijahrane@users.noreply.github.com> Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>
2024-01-04 17:48:57 +01:00
parent a9b797a091
commit eed663e8b4
27 changed files with 468 additions and 361 deletions
--- a/Content.Client/Overlays/EntityHealthBarOverlay.cs
+++ b/Content.Client/Overlays/EntityHealthBarOverlay.cs
@@ -0,0 +1,170 @@
+using Content.Shared.Damage;
+using Content.Shared.FixedPoint;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using System.Numerics;
+using static Robust.Shared.Maths.Color;
+
+namespace Content.Client.Overlays;
+
+/// <summary>
+/// Overlay that shows a health bar on mobs.
+/// </summary>
+public sealed class EntityHealthBarOverlay : Overlay
+{
+    private readonly IEntityManager _entManager;
+    private readonly SharedTransformSystem _transform;
+    private readonly MobStateSystem _mobStateSystem;
+    private readonly MobThresholdSystem _mobThresholdSystem;
+    public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
+    public HashSet<string> DamageContainers = new();
+
+    public EntityHealthBarOverlay(IEntityManager entManager)
+    {
+        _entManager = entManager;
+        _transform = _entManager.EntitySysManager.GetEntitySystem<SharedTransformSystem>();
+        _mobStateSystem = _entManager.EntitySysManager.GetEntitySystem<MobStateSystem>();
+        _mobThresholdSystem = _entManager.EntitySysManager.GetEntitySystem<MobThresholdSystem>();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        var handle = args.WorldHandle;
+        var rotation = args.Viewport.Eye?.Rotation ?? Angle.Zero;
+        var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
+
+        const float scale = 1f;
+        var scaleMatrix = Matrix3.CreateScale(new Vector2(scale, scale));
+        var rotationMatrix = Matrix3.CreateRotation(-rotation);
+
+        var query = _entManager.AllEntityQueryEnumerator<MobThresholdsComponent, MobStateComponent, DamageableComponent, SpriteComponent>();
+        while (query.MoveNext(out var uid,
+            out var mobThresholdsComponent,
+            out var mobStateComponent,
+            out var damageableComponent,
+            out var spriteComponent))
+        {
+            if (_entManager.TryGetComponent<MetaDataComponent>(uid, out var metaDataComponent) &&
+                metaDataComponent.Flags.HasFlag(MetaDataFlags.InContainer))
+            {
+                continue;
+            }
+
+            if (!xformQuery.TryGetComponent(uid, out var xform) ||
+                xform.MapID != args.MapId)
+            {
+                continue;
+            }
+
+            if (damageableComponent.DamageContainerID == null || !DamageContainers.Contains(damageableComponent.DamageContainerID))
+            {
+                continue;
+            }
+
+            var bounds = spriteComponent.Bounds;
+            var worldPos = _transform.GetWorldPosition(xform, xformQuery);
+
+            if (!bounds.Translated(worldPos).Intersects(args.WorldAABB))
+            {
+                continue;
+            }
+
+            var worldPosition = _transform.GetWorldPosition(xform);
+            var worldMatrix = Matrix3.CreateTranslation(worldPosition);
+
+            Matrix3.Multiply(scaleMatrix, worldMatrix, out var scaledWorld);
+            Matrix3.Multiply(rotationMatrix, scaledWorld, out var matty);
+
+            handle.SetTransform(matty);
+
+            var yOffset = spriteComponent.Bounds.Height * EyeManager.PixelsPerMeter / 2 - 3f;
+            var widthOfMob = spriteComponent.Bounds.Width * EyeManager.PixelsPerMeter;
+
+            var position = new Vector2(-widthOfMob / EyeManager.PixelsPerMeter / 2, yOffset / EyeManager.PixelsPerMeter);
+
+            // we are all progressing towards death every day
+            (float ratio, bool inCrit) deathProgress = CalcProgress(uid, mobStateComponent, damageableComponent, mobThresholdsComponent);
+
+            var color = GetProgressColor(deathProgress.ratio, deathProgress.inCrit);
+
+            // Hardcoded width of the progress bar because it doesn't match the texture.
+            const float startX = 8f;
+            var endX = widthOfMob - 8f;
+
+            var xProgress = (endX - startX) * deathProgress.ratio + startX;
+
+            var boxBackground = new Box2(new Vector2(startX, 0f) / EyeManager.PixelsPerMeter, new Vector2(endX, 3f) / EyeManager.PixelsPerMeter);
+            boxBackground = boxBackground.Translated(position);
+            handle.DrawRect(boxBackground, Black.WithAlpha(192));
+
+            var boxMain = new Box2(new Vector2(startX, 0f) / EyeManager.PixelsPerMeter, new Vector2(xProgress, 3f) / EyeManager.PixelsPerMeter);
+            boxMain = boxMain.Translated(position);
+            handle.DrawRect(boxMain, color);
+
+            var pixelDarken = new Box2(new Vector2(startX, 2f) / EyeManager.PixelsPerMeter, new Vector2(xProgress, 3f) / EyeManager.PixelsPerMeter);
+            pixelDarken = pixelDarken.Translated(position);
+            handle.DrawRect(pixelDarken, Black.WithAlpha(128));
+        }
+
+        handle.UseShader(null);
+        handle.SetTransform(Matrix3.Identity);
+    }
+
+    /// <summary>
+    /// Returns a ratio between 0 and 1, and whether the entity is in crit.
+    /// </summary>
+    private (float, bool) CalcProgress(EntityUid uid, MobStateComponent component, DamageableComponent dmg, MobThresholdsComponent thresholds)
+    {
+        if (_mobStateSystem.IsAlive(uid, component))
+        {
+            if (!_mobThresholdSystem.TryGetThresholdForState(uid, MobState.Critical, out var threshold, thresholds) &&
+                !_mobThresholdSystem.TryGetThresholdForState(uid, MobState.Dead, out threshold, thresholds))
+                return (1, false);
+
+            var ratio = 1 - ((FixedPoint2) (dmg.TotalDamage / threshold)).Float();
+            return (ratio, false);
+        }
+
+        if (_mobStateSystem.IsCritical(uid, component))
+        {
+            if (!_mobThresholdSystem.TryGetThresholdForState(uid, MobState.Critical, out var critThreshold, thresholds) ||
+                !_mobThresholdSystem.TryGetThresholdForState(uid, MobState.Dead, out var deadThreshold, thresholds))
+            {
+                return (1, true);
+            }
+
+            var ratio = 1 - ((dmg.TotalDamage - critThreshold) / (deadThreshold - critThreshold)).Value.Float();
+
+            return (ratio, true);
+        }
+
+        return (0, true);
+    }
+
+    public static Color GetProgressColor(float progress, bool crit)
+    {
+        if (progress >= 1.0f)
+        {
+            return SeaBlue;
+        }
+
+        if (!crit)
+        {
+            switch (progress)
+            {
+                case > 0.90F:
+                    return SeaBlue;
+                case > 0.50F:
+                    return Violet;
+                case > 0.15F:
+                    return Ruber;
+            }
+        }
+
+        return VividGamboge;
+    }
+}
--- a/Content.Client/Overlays/EquipmentHudSystem.cs
+++ b/Content.Client/Overlays/EquipmentHudSystem.cs
@@ -72,7 +72,7 @@ public abstract class EquipmentHudSystem<T> : EntitySystem where T : IComponent

    private void OnPlayerDetached(LocalPlayerDetachedEvent args)
    {
-        if (_player.LocalPlayer?.ControlledEntity == null)
+        if (_player.LocalSession?.AttachedEntity == null)
            Deactivate();
    }

@@ -93,17 +93,18 @@ public abstract class EquipmentHudSystem<T> : EntitySystem where T : IComponent

    protected virtual void OnRefreshEquipmentHud(EntityUid uid, T component, InventoryRelayedEvent<RefreshEquipmentHudEvent<T>> args)
    {
-        args.Args.Active = true;
+        OnRefreshComponentHud(uid, component, args.Args);
    }

    protected virtual void OnRefreshComponentHud(EntityUid uid, T component, RefreshEquipmentHudEvent<T> args)
    {
        args.Active = true;
+        args.Components.Add(component);
    }

    private void RefreshOverlay(EntityUid uid)
    {
-        if (uid != _player.LocalPlayer?.ControlledEntity)
+        if (uid != _player.LocalSession?.AttachedEntity)
            return;

        var ev = new RefreshEquipmentHudEvent<T>(TargetSlots);
--- a/Content.Client/Overlays/ShowHealthBarsSystem.cs
+++ b/Content.Client/Overlays/ShowHealthBarsSystem.cs
@@ -0,0 +1,46 @@
+using Content.Shared.Inventory.Events;
+using Content.Shared.Overlays;
+using Robust.Client.Graphics;
+using System.Linq;
+
+namespace Content.Client.Overlays;
+
+/// <summary>
+/// Adds a health bar overlay.
+/// </summary>
+public sealed class ShowHealthBarsSystem : EquipmentHudSystem<ShowHealthBarsComponent>
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+    private EntityHealthBarOverlay _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _overlay = new(EntityManager);
+    }
+
+    protected override void UpdateInternal(RefreshEquipmentHudEvent<ShowHealthBarsComponent> component)
+    {
+        base.UpdateInternal(component);
+
+        foreach (var damageContainerId in component.Components.SelectMany(x => x.DamageContainers))
+        {
+            _overlay.DamageContainers.Add(damageContainerId);
+        }
+
+        if (!_overlayMan.HasOverlay<EntityHealthBarOverlay>())
+        {
+            _overlayMan.AddOverlay(_overlay);
+        }
+    }
+
+    protected override void DeactivateInternal()
+    {
+        base.DeactivateInternal();
+
+        _overlay.DamageContainers.Clear();
+        _overlayMan.RemoveOverlay(_overlay);
+    }
+}
--- a/Content.Client/Overlays/ShowHealthIconsSystem.cs
+++ b/Content.Client/Overlays/ShowHealthIconsSystem.cs
@@ -0,0 +1,77 @@
+using Content.Shared.Damage;
+using Content.Shared.Inventory.Events;
+using Content.Shared.Overlays;
+using Content.Shared.StatusIcon;
+using Content.Shared.StatusIcon.Components;
+using Robust.Shared.Prototypes;
+using System.Linq;
+
+namespace Content.Client.Overlays;
+
+/// <summary>
+/// Shows a healthy icon on mobs.
+/// </summary>
+public sealed class ShowHealthIconsSystem : EquipmentHudSystem<ShowHealthIconsComponent>
+{
+    [Dependency] private readonly IPrototypeManager _prototypeMan = default!;
+
+    public HashSet<string> DamageContainers = new();
+
+    [ValidatePrototypeId<StatusIconPrototype>]
+    private const string HealthIconFine = "HealthIconFine";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<DamageableComponent, GetStatusIconsEvent>(OnGetStatusIconsEvent);
+
+    }
+
+    protected override void UpdateInternal(RefreshEquipmentHudEvent<ShowHealthIconsComponent> component)
+    {
+        base.UpdateInternal(component);
+
+        foreach (var damageContainerId in component.Components.SelectMany(x => x.DamageContainers))
+        {
+            DamageContainers.Add(damageContainerId);
+        }
+    }
+
+    protected override void DeactivateInternal()
+    {
+        base.DeactivateInternal();
+
+        DamageContainers.Clear();
+    }
+
+    private void OnGetStatusIconsEvent(EntityUid uid, DamageableComponent damageableComponent, ref GetStatusIconsEvent args)
+    {
+        if (!IsActive || args.InContainer)
+            return;
+
+        var healthIcons = DecideHealthIcons(damageableComponent);
+
+        args.StatusIcons.AddRange(healthIcons);
+    }
+
+    private IReadOnlyList<StatusIconPrototype> DecideHealthIcons(DamageableComponent damageableComponent)
+    {
+        if (damageableComponent.DamageContainerID == null ||
+            !DamageContainers.Contains(damageableComponent.DamageContainerID))
+        {
+            return Array.Empty<StatusIconPrototype>();
+        }
+
+        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))
+        {
+            result.Add(healthyIcon);
+        }
+
+        return result;
+    }
+}
--- a/Content.Client/Overlays/ShowHungerIconsSystem.cs
+++ b/Content.Client/Overlays/ShowHungerIconsSystem.cs
@@ -22,9 +22,9 @@ public sealed class ShowHungerIconsSystem : EquipmentHudSystem<ShowHungerIconsCo
        if (!IsActive || args.InContainer)
            return;

-        var healthIcons = DecideHungerIcon(uid, hungerComponent);
+        var hungerIcons = DecideHungerIcon(uid, hungerComponent);

-        args.StatusIcons.AddRange(healthIcons);
+        args.StatusIcons.AddRange(hungerIcons);
    }

    private IReadOnlyList<StatusIconPrototype> DecideHungerIcon(EntityUid uid, HungerComponent hungerComponent)
--- a/Content.Client/Overlays/ShowSecurityIconsSystem.cs
+++ b/Content.Client/Overlays/ShowSecurityIconsSystem.cs
@@ -8,6 +8,7 @@ using Content.Shared.StatusIcon.Components;
 using Robust.Shared.Prototypes;

 namespace Content.Client.Overlays;
+
 public sealed class ShowSecurityIconsSystem : EquipmentHudSystem<ShowSecurityIconsComponent>
 {
    [Dependency] private readonly IPrototypeManager _prototypeMan = default!;
@@ -30,9 +31,9 @@ public sealed class ShowSecurityIconsSystem : EquipmentHudSystem<ShowSecurityIco
            return;
        }

-        var healthIcons = DecideSecurityIcon(uid);
+        var securityIcons = DecideSecurityIcon(uid);

-        @event.StatusIcons.AddRange(healthIcons);
+        @event.StatusIcons.AddRange(securityIcons);
    }

    private IReadOnlyList<StatusIconPrototype> DecideSecurityIcon(EntityUid uid)
--- a/Content.Client/Overlays/ShowSyndicateIconsSystem.cs
+++ b/Content.Client/Overlays/ShowSyndicateIconsSystem.cs
@@ -23,9 +23,9 @@ public sealed class ShowSyndicateIconsSystem : EquipmentHudSystem<ShowSyndicateI
            return;
        }

-        var healthIcons = SyndicateIcon(uid, nukeOperativeComponent);
+        var syndicateIcons = SyndicateIcon(uid, nukeOperativeComponent);

-        args.StatusIcons.AddRange(healthIcons);
+        args.StatusIcons.AddRange(syndicateIcons);
    }

    private IReadOnlyList<StatusIconPrototype> SyndicateIcon(EntityUid uid, NukeOperativeComponent nukeOperativeComponent)
--- a/Content.Client/Overlays/ShowThirstIconsSystem.cs
+++ b/Content.Client/Overlays/ShowThirstIconsSystem.cs
@@ -22,9 +22,9 @@ public sealed class ShowThirstIconsSystem : EquipmentHudSystem<ShowThirstIconsCo
        if (!IsActive || args.InContainer)
            return;

-        var healthIcons = DecideThirstIcon(uid, thirstComponent);
+        var thirstIcons = DecideThirstIcon(uid, thirstComponent);

-        args.StatusIcons.AddRange(healthIcons);
+        args.StatusIcons.AddRange(thirstIcons);
    }

    private IReadOnlyList<StatusIconPrototype> DecideThirstIcon(EntityUid uid, ThirstComponent thirstComponent)