HealthBarWidget.cs

using System.Drawing;
using System.Numerics;
using Gondwana.Drawing.Direct;
using Gondwana.Drawing.Sprites;
using Gondwana.Rendering;
 
namespace Gondwana.Widgets.Hud;

public sealed class HealthBarWidget : WidgetBase
{
    private const int InnerPadding = 2;
 
    private readonly DirectRectangle _track;
    private readonly DirectRectangle _fill;
 
    private bool _disposed;
    private float _maximum;
    private float _value;
    private Size _size;
    private Point _offsetPx;

    public HealthBarWidget(
        RenderSurfaceHostBase renderSurfaceHost,
        Sprite target,
        float maximum,
        Size? size = null,
        Point? offsetPx = null,
        string? nickname = null)
        : base(
            renderSurfaceHost,
            DirectDrawingMode.SceneLayer,
            nickname: nickname)
    {
        Target = target ?? throw new ArgumentNullException(nameof(target));
 
        if (maximum <= 0f)
            throw new ArgumentOutOfRangeException(nameof(maximum), "Maximum health must be greater than zero.");
 
        _maximum = maximum;
        _value = maximum;
        _size = ValidateSize(size ?? new Size(64, 9));
        _offsetPx = offsetPx ?? Point.Empty;
 
        IsInputEnabled = false;
        IsPointerInputEnabled = false;
 
        _track = new DirectRectangle(
                Color.FromArgb(220, 20, 24, 31),
                renderSurfaceHost,
                Target.SceneLayer,
                new Rectangle(Point.Empty, _size),
                $"{nickname ?? Target.Nickname ?? "sprite"}-health-track")
            .SetFilled(true)
            .SetBorderColor(Color.FromArgb(235, 235, 241, 247))
            .SetStrokeWidth(1f)
            .SetStrokeAlign(DirectRectangle.StrokeAlign.Inside)
            .SetCornerRadius(2f);
 
        _fill = new DirectRectangle(
                Color.FromArgb(245, 55, 210, 105),
                renderSurfaceHost,
                Target.SceneLayer,
                GetFillBounds(Point.Empty),
                $"{nickname ?? Target.Nickname ?? "sprite"}-health-fill")
            .SetFilled(true)
            .SetStrokeWidth(0f)
            .SetCornerRadius(1f);
 
        Add(
            _track,
            keepCurrentOffset: false,
            explicitLocalOffsetPx: Vector2.Zero);
 
        Add(
            _fill,
            keepCurrentOffset: false,
            explicitLocalOffsetPx: new Vector2(InnerPadding, InnerPadding));
 
        Target.SpriteMoved += OnTargetMoved;
        Target.Disposing += OnTargetDisposing;
 
        RefreshPosition();
        UpdateFillBounds();
    }

    public Sprite Target { get; }

    public float Maximum
    {
        get => _maximum;
        set
        {
            if (value <= 0f)
                throw new ArgumentOutOfRangeException(nameof(value), "Maximum health must be greater than zero.");
 
            _maximum = value;
            _value = Math.Clamp(_value, 0f, _maximum);
            UpdateFillBounds();
        }
    }

    public float Value
    {
        get => _value;
        set
        {
            float clamped = Math.Clamp(value, 0f, Maximum);
 
            if (_value.Equals(clamped))
                return;
 
            _value = clamped;
            UpdateFillBounds();
        }
    }

    public float Fraction => Value / Maximum;

    public Size Size
    {
        get => _size;
        set
        {
            Size validated = ValidateSize(value);
 
            if (_size == validated)
                return;
 
            _size = validated;
            _track.WorldBounds = new Rectangle(_track.WorldBounds.Location, _size);
            RefreshPosition();
            UpdateFillBounds();
        }
    }

    public Point OffsetPx
    {
        get => _offsetPx;
        set
        {
            _offsetPx = value;
            RefreshPosition();
        }
    }

    public Rectangle TrackBoundsWorld => _track.WorldBounds;

    public Rectangle FillBoundsWorld => _fill.WorldBounds;

    public HealthBarWidget SetValue(float value)
    {
        Value = value;
        return this;
    }

    public HealthBarWidget SetFillColor(Color color)
    {
        _fill.SetColor(color);
        return this;
    }

    public void RefreshPosition()
    {
        Rectangle targetBounds = Target.DrawLocationWorld;
        int x = targetBounds.Left + (targetBounds.Width - Size.Width) / 2 + OffsetPx.X;
        int y = targetBounds.Top - Size.Height - 6 + OffsetPx.Y;
 
        SetPosition(x, y);
    }

    public override void Dispose()
    {
        if (_disposed)
            return;
 
        _disposed = true;
        Target.SpriteMoved -= OnTargetMoved;
        Target.Disposing -= OnTargetDisposing;
        base.Dispose();
    }

    protected override void ProcessShown()
    {
        base.ProcessShown();
        _fill.Visible = Value > 0f;
    }
 
    private void OnTargetMoved(SpriteMovedEventArgs args)
    {
        RefreshPosition();
    }
 
    private void OnTargetDisposing(Sprite sprite)
    {
        Dispose();
    }
 
    private void UpdateFillBounds()
    {
        Point location = _fill.WorldBounds.Location;
        Rectangle fillBounds = GetFillBounds(location);
 
        _fill.WorldBounds = fillBounds;
        _fill.Visible = Value > 0f && _track.Visible;
    }
 
    private Rectangle GetFillBounds(Point location)
    {
        int availableWidth = Math.Max(0, Size.Width - InnerPadding * 2);
        int availableHeight = Math.Max(1, Size.Height - InnerPadding * 2);
        int fillWidth = (int)MathF.Round(availableWidth * Fraction);
 
        return new Rectangle(location, new Size(fillWidth, availableHeight));
    }
 
    private static Size ValidateSize(Size value)
    {
        if (value.Width < InnerPadding * 2 + 1)
            throw new ArgumentOutOfRangeException(nameof(value), "Health-bar width is too small.");
 
        if (value.Height < InnerPadding * 2 + 1)
            throw new ArgumentOutOfRangeException(nameof(value), "Health-bar height is too small.");
 
        return value;
    }
}