CompositeSprite.cs

using System.Collections.ObjectModel;
using System.Drawing;
using System.Numerics;
using System.Runtime.Serialization;
using Gondwana.Physics.Movement;
using Gondwana.Scenes;
using Newtonsoft.Json;
 
namespace Gondwana.Drawing.Sprites;

public class CompositeSprite : IMovableOnSceneLayer
{
    [JsonProperty]
    private readonly List<Sprite> _children = new();

    [JsonProperty]
    public CompositeAnchorMode AnchorMode { get; set; } = CompositeAnchorMode.TopLeft;
 
    #region ctor

    public CompositeSprite() { }

    public CompositeSprite(List<Sprite> sprites)
    {
        foreach (var sprite in sprites)
            Add(sprite);
    }

    public CompositeSprite(params Sprite[] sprites) : this(sprites.ToList())
    {
    }
 
    [OnDeserialized]
    private void OnDeserialized(StreamingContext context)
    {
        foreach (var sprite in _children)
            sprite.Disposing += sprite_Disposing;
    }
 
    #endregion ctor
 
    #region IMovable / IMovableOnSceneLayer

    [JsonIgnore]
    public MovementSpace PositionSpace => MovementSpace.Grid;

    [JsonIgnore]
    public SceneLayer SceneLayer
    {
        get
        {
            if (_children.Count == 0)
                throw new InvalidOperationException("CompositeSprite has no children; SceneLayer is undefined.");
 
            // Enforced by Add(...) invariants.
            return _children[0].SceneLayer;
        }
    }

    public Vector2 GetPosition()
    {
        Rectangle r = Range;
        if (r == Rectangle.Empty)
            return Vector2.Zero;
 
        PointF anchorWorldPx = AnchorMode switch
        {
            CompositeAnchorMode.TopLeft => new PointF(r.Left, r.Top),
            CompositeAnchorMode.Center => new PointF(
                r.Left + (r.Width / 2f),
                r.Top + (r.Height / 2f)),
            _ => new PointF(r.Left, r.Top)
        };
 
        PointF anchorGrid = SceneLayer.WorldPxToGrid(anchorWorldPx);
        return new Vector2(anchorGrid.X, anchorGrid.Y);
    }

    public void SetPosition(Vector2 pos)
    {
        Vector2 oldAnchor = GetPosition();
        Vector2 delta = pos - oldAnchor;
 
        if (delta == Vector2.Zero || _children.Count == 0)
            return;
 
        // Translate all children by delta based on their CURRENT positions.
        // This preserves independent child movement naturally.
        foreach (var sprite in _children)
        {
            Vector2 childPos = GetSpritePosition(sprite);
            sprite.SetPosition(childPos + delta);
        }
    }

    public void Translate(Vector2 delta)
    {
        if (delta == Vector2.Zero)
            return;
 
        SetPosition(GetPosition() + delta);
    }
 
    #endregion IMovable / IMovableOnSceneLayer
 
    #region methods

    public void Add(Sprite sprite)
    {
        if (sprite is null) throw new ArgumentNullException(nameof(sprite));
        if (_children.Contains(sprite)) return;
 
        EnforceSameSceneLayer(sprite);
 
        sprite.Disposing += sprite_Disposing;
        _children.Add(sprite);
    }

    public void AddChildAtPosition(Sprite sprite, Vector2 absolutePosition)
    {
        if (sprite is null) throw new ArgumentNullException(nameof(sprite));
        if (_children.Contains(sprite)) return;
 
        EnforceSameSceneLayer(sprite);
 
        sprite.Disposing += sprite_Disposing;
        _children.Add(sprite);
 
        sprite.SetPosition(absolutePosition);
    }

    public void AddChildWithOffset(Sprite sprite, Vector2 offsetFromCompositeAnchor)
    {
        if (sprite is null) throw new ArgumentNullException(nameof(sprite));
        if (_children.Contains(sprite)) return;
 
        EnforceSameSceneLayer(sprite);
 
        // If this is the first child:
        // - Its CURRENT position becomes the anchor.
        // - Offset is interpreted relative to that, so we only reposition if offset != 0.
        if (_children.Count == 0)
        {
            sprite.Disposing += sprite_Disposing;
            _children.Add(sprite);
 
            Vector2 firstPos = GetSpritePosition(sprite);
            Vector2 target = firstPos + offsetFromCompositeAnchor;
 
            if (offsetFromCompositeAnchor != Vector2.Zero)
                sprite.SetPosition(target);
 
            return;
        }
 
        // Otherwise offset is from the current composite anchor (derived from Range).
        Vector2 anchor = GetPosition();
        AddChildAtPosition(sprite, anchor + offsetFromCompositeAnchor);
    }

    public void Remove(Sprite sprite)
    {
        if (sprite is null) return;
        if (!_children.Contains(sprite)) return;
 
        sprite.Disposing -= sprite_Disposing;
        _children.Remove(sprite);
    }
 
    private void sprite_Disposing(Sprite sprite)
    {
        sprite.Disposing -= sprite_Disposing;
        _children.Remove(sprite);
    }
 
    private void EnforceSameSceneLayer(Sprite sprite)
    {
        if (_children.Count == 0)
            return;
 
        if (!ReferenceEquals(sprite.SceneLayer, _children[0].SceneLayer))
            throw new InvalidOperationException("All sprites in a CompositeSprite must belong to the same SceneLayer.");
    }
 
    private static Vector2 GetSpritePosition(Sprite sprite)
    {
        // Adjust this if your Sprite uses a different property name/type.
        // Assumed: SceneLayerCoordinates is PointF.
        PointF p = sprite.SceneLayerCoordinates;
        return new Vector2(p.X, p.Y);
    }
 
    #endregion methods
 
    #region properties

    [JsonIgnore]
    public ReadOnlyCollection<Sprite> Children => _children.AsReadOnly();

    [JsonIgnore]
    public Rectangle Range
    {
        get
        {
            if (_children.Count == 0)
                return Rectangle.Empty;
 
            int minX = int.MaxValue;
            int minY = int.MaxValue;
            int maxX = int.MinValue;
            int maxY = int.MinValue;
 
            foreach (var sprite in _children)
            {
                var r = sprite.DrawLocationWorld;
 
                if (r.Left < minX) minX = r.Left;
                if (r.Top < minY) minY = r.Top;
                if (r.Right > maxX) maxX = r.Right;
                if (r.Bottom > maxY) maxY = r.Bottom;
            }
 
            return Rectangle.FromLTRB(minX, minY, maxX, maxY);
        }
    }
 
    #endregion properties
}

public enum CompositeAnchorMode
{
    TopLeft = 0,

    Center = 1
}