FixedStepAccumulator.cs

namespace Gondwana.Timers;

internal sealed class FixedStepAccumulator
{
    private long _lastDriverTick;
    private long _accumulatedTicks;

    internal long SimulationTick { get; private set; }

    internal void Reset(long tick)
    {
        _lastDriverTick = tick;
        _accumulatedTicks = 0;
        SimulationTick = tick;
    }

    internal FixedStepBatch Advance(long driverTick, int updatesPerSecond, int maxSteps)
    {
        if (updatesPerSecond <= 0)
            throw new ArgumentOutOfRangeException(nameof(updatesPerSecond));
        if (maxSteps <= 0)
            throw new ArgumentOutOfRangeException(nameof(maxSteps));
 
        long stepTicks = Math.Max(1, HighResTimer.TicksPerSecond / updatesPerSecond);
        long elapsedTicks = driverTick > _lastDriverTick
            ? driverTick - _lastDriverTick
            : 0;
 
        if (driverTick > _lastDriverTick)
            _lastDriverTick = driverTick;
 
        long maxAccumulatedTicks = stepTicks > long.MaxValue / maxSteps
            ? long.MaxValue
            : stepTicks * maxSteps;
 
        _accumulatedTicks = elapsedTicks >= maxAccumulatedTicks - _accumulatedTicks
            ? maxAccumulatedTicks
            : _accumulatedTicks + elapsedTicks;
 
        int stepCount = (int)Math.Min(maxSteps, _accumulatedTicks / stepTicks);
        _accumulatedTicks -= stepCount * stepTicks;
 
        long firstStepTick = SimulationTick + stepTicks;
        SimulationTick += stepCount * stepTicks;
 
        return new FixedStepBatch(firstStepTick, stepTicks, stepCount);
    }
}

internal readonly record struct FixedStepBatch(long FirstStepTick, long StepTicks, int StepCount)
{
    internal long GetStepTick(int index)
    {
        if ((uint)index >= (uint)StepCount)
            throw new ArgumentOutOfRangeException(nameof(index));
 
        return FirstStepTick + (index * StepTicks);
    }
}