FrameSequence.cs

using System.Collections;
using System.Runtime.Serialization;
using Gondwana.Drawing.Tilesheets;
using Newtonsoft.Json;
 
namespace Gondwana.Drawing.Animation;

public struct FrameSequence : IEnumerable<Frame>
{
    #region fields

    [JsonProperty]
    public CycleType SequenceCycleType;
 
    [JsonProperty]
    private List<Frame> frameList;
 
    [JsonProperty]
    private List<double?>? frameDurations;

    public double? GetDurationSeconds(int index) =>
        frameDurations is not null && index < frameDurations.Count ? frameDurations[index] : null;

    public void SetDurationSeconds(int index, double? seconds)
    {
        if (index < 0 || index >= FrameCount) throw new ArgumentOutOfRangeException(nameof(index));
        if (seconds is { } duration && (!double.IsFinite(duration) || duration <= 0))
            throw new ArgumentOutOfRangeException(nameof(seconds));
        // Copy on write: cloned cycles share images, but editing timing must not change the original.
        frameDurations = frameDurations is null ? new List<double?>() : new(frameDurations);
        while (frameDurations.Count < FrameCount) frameDurations.Add(null);
        frameDurations[index] = seconds;
    }
 
    internal void SetDurations(IEnumerable<double?> durations)
    {
        var values = durations.ToList();
        if (values.Count != FrameCount || values.Any(v => v is { } d && (!double.IsFinite(d) || d <= 0)))
            throw new ArgumentException("Durations must match the sequence and be positive finite values or null.", nameof(durations));
        frameDurations = values.Any(v => v.HasValue) ? values : null;
    }
 
    private int currentFrameIdx;
    private int curFrameIncrement;
    private bool cycleFinished;
 
    #endregion fields
 
    #region constructors / finalizer

    public FrameSequence(Frame frame)
    {
        frameList = new List<Frame>();
        frameList.Add(frame);
        SequenceCycleType = CycleType.Simple;
        currentFrameIdx = 0;
        curFrameIncrement = 1;
        cycleFinished = true;
    }

    public FrameSequence(List<Frame> frames)
    {
        frameList = frames;
        SequenceCycleType = CycleType.Simple;
        currentFrameIdx = 0;
        curFrameIncrement = 1;
        cycleFinished = true;
    }
 
    [OnDeserialized()]
    private void OnDeserialized(StreamingContext context)
    {
        currentFrameIdx = 0;
        curFrameIncrement = 1;
        cycleFinished = true;
    }
 
    #endregion constructors / finalizer
 
    #region properties

    [JsonIgnore]
    public bool CycleFinished
    {
        get { return cycleFinished; }
    }

    [JsonIgnore]
    public int FrameCount
    {
        get
        {
            if (frameList == null)
                SetDefaults();
 
            return frameList.Count;
        }
    }

    [JsonIgnore]
    public Frame CurrentFrame
    {
        get
        {
            if (frameList == null)
                SetDefaults();
 
            return frameList[currentFrameIdx];
        }
    }

    [JsonIgnore]
    public int CurrentFrameIdx
    {
        get { return currentFrameIdx; }
    }

    [JsonIgnore]
    public IList<Frame> FrameList
    {
        get { return frameList.AsReadOnly(); }
    }
 
    #endregion properties
 
    #region public methods

    public Frame AddFrame(Tilesheet bmp, string regionName, int xTile, int yTile)
    {
        return AddFrame(new Frame(bmp, regionName, xTile, yTile));
    }

    public Frame AddFrame(Tilesheet bmp, int xTile, int yTile)
    {
        return AddFrame(new Frame(bmp, TilesheetRegion.DefaultRegionName, xTile, yTile));
    }

    public Frame AddFrame(Frame frame)
    {
        if (frameList == null)
            SetDefaults();
 
        frameList.Add(frame);
        return frame;
    }

    public void RemoveFrame(int idx)
    {
        if (idx < frameList.Count)
        {
            frameList.RemoveAt(idx);
            if (frameDurations is not null && idx < frameDurations.Count)
            {
                frameDurations = new(frameDurations);
                frameDurations.RemoveAt(idx);
            }
        }
    }

    public void Reset()
    {
        currentFrameIdx = 0;
        curFrameIncrement = 1;
    }
 
    #endregion public methods
 
    #region internal methods
 
    internal void StopCycle()
    {
        cycleFinished = true;
    }
 
    internal Frame AdvanceFrame()
    {
        switch (SequenceCycleType)
        {
            case CycleType.PingPong:
                currentFrameIdx += curFrameIncrement;
                if ((currentFrameIdx <= 0) || (currentFrameIdx >= frameList.Count - 1))
                    curFrameIncrement *= -1;
 
                if (currentFrameIdx < 0)
                    currentFrameIdx = 0;
 
                if (currentFrameIdx > frameList.Count - 1)
                    currentFrameIdx = frameList.Count - 1;
 
                cycleFinished = false;
                break;
 
            case CycleType.Repeating:
                if (++currentFrameIdx >= frameList.Count)
                    currentFrameIdx = 0;
 
                cycleFinished = false;
                break;
 
            case CycleType.Simple:
                if (++currentFrameIdx > frameList.Count - 1)
                {
                    currentFrameIdx = frameList.Count - 1;
                    cycleFinished = true;
                }
                else
                    cycleFinished = false;
                break;
 
            default:
                throw new InvalidOperationException("Invalid CycleType: " + SequenceCycleType.ToString());
        }
 
        return frameList[currentFrameIdx];
    }
 
    #endregion internal methods
 
    #region private methods
 
    private void SetDefaults()
    {
        frameList = new List<Frame>();
        SequenceCycleType = CycleType.Simple;
        currentFrameIdx = 0;
        curFrameIncrement = 1;
        cycleFinished = true;
    }
 
    #endregion private methods
 
    #region indexers

    public Frame this[int frameIdx]
    {
        get { return frameList[frameIdx]; }
    }
 
    #endregion indexers
 
    #region IEnumerable Members

    public IEnumerator GetEnumerator()
    {
        for (int i = 0; i < frameList.Count; i++)
            yield return frameList[i];
    }

    IEnumerator<Frame> IEnumerable<Frame>.GetEnumerator()
    {
        return frameList.GetEnumerator();
    }
 
    #endregion IEnumerable Members
}