SpriteManager.cs

using System.Collections.ObjectModel;
using System.Drawing;
using Gondwana.Physics.Collisions;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.SkiaSharp;
using Gondwana.Timers;
 
namespace Gondwana.Drawing.Sprites;

public sealed class SpriteManager : IDisposable
{
    [Newtonsoft.Json.JsonIgnore]
    internal DefinitionProvenance? DefinitionProvenance { get; set; }
 
    private static readonly Lazy<SpriteManager> _instance = new(() => new SpriteManager());

    public static SpriteManager Instance => _instance.Value;
 
    internal readonly List<Sprite> _spriteList = new();
    private readonly object _spriteListLock = new();
 
    private long _lastTick = EngineSimulationClock.GetCurrentTick();

    public event Action<Sprite>? SpriteCreated;
 
    private SpriteManager() { }

    public ReadOnlyCollection<Sprite> AllSprites
    {
        get
        {
            lock (_spriteListLock)
                return new List<Sprite>(_spriteList).AsReadOnly();
        }
    }

    public bool SizeNewSpritesToSceneLayer { get; set; } = true;
 
    private string _defaultCollisionProfile = CollisionProfileNames.Actor;

    public string DefaultCollisionProfile
    {
        get => _defaultCollisionProfile;
        set
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Default collision profile cannot be empty.", nameof(value));
 
            _defaultCollisionProfile = value;
        }
    }
    #region public methods

    public Sprite CreateSprite(
        SceneLayer sceneLayer,
        Frame frame,
        string? id = null,
        string? collisionProfileName = null)
    {
        var profileName = string.IsNullOrWhiteSpace(collisionProfileName)
            ? DefaultCollisionProfile
            : collisionProfileName;
 
        var sprite = new Sprite(sceneLayer, frame, profileName);
        sprite.Nickname = id;
        PublishCreatedSprite(sprite);
        return sprite;
    }

    public Sprite CloneSprite(Sprite sprite) => CloneSprite(sprite, sprite.SceneLayer);

    public Sprite CloneSprite(Sprite sprite, SceneLayer sceneLayer)
    {
        Sprite newSprite = new Sprite(sprite, sceneLayer);
 
        PublishCreatedSprite(newSprite);
        return newSprite;
    }

    public Sprite? CloneSprite(string id, SceneLayer sceneLayer)
    {
        Sprite? sprite = GetSpriteByID(id);
 
        if (sprite != null)
            return CloneSprite(sprite, sceneLayer);
 
        return null;
    }

    public void Remove(Sprite sprite)
    {
        sprite.Dispose();
    }

    public void Remove(string ID)
    {
        Sprite? sprite = GetSpriteByID(ID);
        if (sprite != null)
            Remove(sprite);
    }

    public void Clear()
    {
        DefinitionProvenance = null;
        List<Sprite> tempSprites;
        lock (_spriteListLock)
            tempSprites = new List<Sprite>(_spriteList);
        foreach (Sprite sprite in tempSprites)
            Remove(sprite);
    }

    public Sprite? GetSpriteByID(string ID)
    {
        List<Sprite> snapshot;
        lock (_spriteListLock)
            snapshot = new List<Sprite>(_spriteList);
 
        foreach (Sprite sprite in snapshot)
        {
            if (sprite.Nickname == ID)
                return sprite;
        }
 
        return null;
    }
 
    internal bool HasVisibleSpriteInWorldRect(
        Rectangle worldRect,
        SceneLayer sceneLayer)
    {
        lock (_spriteListLock)
        {
            for (int i = 0; i < _spriteList.Count; i++)
            {
                var sprite = _spriteList[i];
                if (sprite.Visible &&
                    ReferenceEquals(sprite.SceneLayer, sceneLayer) &&
                    sprite.VisualBoundsWorld.IntersectsWith(worldRect))
                {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    // world
    public List<Sprite> GetSpritesInWorldRectRange(
        Rectangle worldRect,
        SceneLayer? sceneLayer = null,
        bool fullEnclosures = false)
    {
        List<Sprite> retSprites = new();
 
        List<Sprite> snapshot;
        lock (_spriteListLock)
            snapshot = new List<Sprite>(_spriteList);
 
        foreach (Sprite sprite in snapshot)
        {
            if ((sceneLayer is null) || (sprite.SceneLayer == sceneLayer))
            {
                if (fullEnclosures)
                {
                    if (worldRect.Contains(sprite.VisualBoundsWorld))
                        retSprites.Add(sprite);
                }
                else
                {
                    if (sprite.VisualBoundsWorld.IntersectsWith(worldRect))
                        retSprites.Add(sprite);
                }
            }
        }
 
        return retSprites;
    }
 
    // screen
    public List<Sprite> GetSpritesInViewRectRange(
        View view,
        Rectangle viewRectPx,
        SceneLayer? sceneLayer = null,
        bool fullEnclosures = false)
    {
        var retSprites = new List<Sprite>();
 
        List<Sprite> snapshot;
        lock (_spriteListLock)
            snapshot = new List<Sprite>(_spriteList);
 
        foreach (var sprite in snapshot)
        {
            if ((sceneLayer is null) || (sprite.SceneLayer == sceneLayer))
            {
                var rectScreen = sprite.GetVisualBoundsScreen(view).ToPixelAlignedRect();
 
                if (fullEnclosures)
                {
                    if (viewRectPx.Contains(rectScreen))
                        retSprites.Add(sprite);
                }
                else
                {
                    if (rectScreen.IntersectsWith(viewRectPx))
                        retSprites.Add(sprite);
                }
            }
        }
 
        return retSprites;
    }

    public List<Sprite> GetSpritesAtViewPixel(
        View view,
        Point viewPxlPt,
        SceneLayer? sceneLayer = null)
    {
        var retSprites = new List<Sprite>();
 
        List<Sprite> snapshot;
        lock (_spriteListLock)
            snapshot = new List<Sprite>(_spriteList);
 
        foreach (Sprite sprite in snapshot)
        {
            if ((sceneLayer is null) || (sprite.SceneLayer == sceneLayer))
            {
                if (sprite.GetVisualBoundsScreen(view).Contains(viewPxlPt))
                    retSprites.Add(sprite);
            }
        }
 
        return retSprites;
    }
 
    #endregion public methods
 
    #region internal methods
 
    internal void AddSprite(Sprite sprite)
    {
        lock (_spriteListLock)
            _spriteList.Add(sprite);
    }

    internal void RefreshCollisionProfiles(SceneLayer sceneLayer)
    {
        ArgumentNullException.ThrowIfNull(sceneLayer);
 
        List<Sprite> snapshot;
        lock (_spriteListLock)
            snapshot = new List<Sprite>(_spriteList);
 
        foreach (var sprite in snapshot)
        {
            if (sprite is null)
                continue;
 
            if (ReferenceEquals(sprite.SceneLayer, sceneLayer))
                sprite.RefreshCollisionProfile();
        }
    }
 
    internal void MoveSprites(long tick)
    {
        if (tick <= _lastTick)
            return;
 
        float duration = HighResTimer.GetDuration(_lastTick, tick);
 
        lock (_spriteListLock)
        {
            for (int i = 0; i < _spriteList.Count; i++)
            {
                var sprite = _spriteList[i];
 
                if (sprite._pendingDispose)
                    continue;
 
                sprite.Movement.AdvanceMovement(duration);
                sprite.AdvanceResize(duration);
                sprite.AdvanceJiggle(duration);
            }
 
            SweepDisposedSprites();
        }
 
        _lastTick = tick;
    }
 
    private void SweepDisposedSprites()
    {
        int i = 0;
        while (i < _spriteList.Count)
        {
            if (!_spriteList[i]._pendingDispose)
            {
                i++;
                continue;
            }
 
            _spriteList[i].DisposeImmediate();
 
            int last = _spriteList.Count - 1;
            _spriteList[i] = _spriteList[last];
            _spriteList.RemoveAt(last);
        }
    }
 
    private void PublishCreatedSprite(Sprite sprite)
    {
        try
        {
            SpriteCreated?.Invoke(sprite);
        }
        catch
        {
            // The caller cannot roll back an instance that never returned from CreateSprite/CloneSprite.
            lock (_spriteListLock)
                _spriteList.Remove(sprite);
            sprite.DisposeImmediate();
            throw;
        }
    }
 
    #endregion internal methods

    public void Dispose()
    {
        Clear();
    }
}