/// <summary>
/// Decorates an action with re-registeration to the queue based on the provided Beat <see cref="interval"/> value.
/// </summary>
/// <param name="action">The action to decorate with rescheduling.</param>
/// <param name="beatQueue">The beat queue to register it to.</param>
/// <param name="interval">The internal of registeration.</param>
/// <returns>A new decorated action with rescheduling semantics.</returns>
private static Action ReschedulingEvent(Action action, IBeatsEventQueueRegisterable beatQueue, double interval)
{
return(() =>
{
beatQueue.RegisterEvent(TimeService.CurrentBeatsTime + interval, ReschedulingEvent(action, beatQueue, interval));
action();
});
}
/// <summary>
/// Registers a new repeating Beat event that will re-register before firing and will register itself for the
/// difference between the schedule time and the current time.
/// </summary>
/// <param name="beatQueue">The beat queue.</param>
/// <param name="action">The The action to register.</param>
/// <param name="repeatBeatInterval">The beat interval to repeat the event for.</param>
public static void RegisterRepeating(this IBeatsEventQueueRegisterable beatQueue, Action action, double repeatBeatInterval)
{
if (repeatBeatInterval <= 0)
{
throw new ArgumentOutOfRangeException(nameof(repeatBeatInterval), "Cannot request a negative or 0 interval. 0 intervals would cause endless loops during services and negative internvals are nonsense.");
}
//Register an event that reschedules itself before being fired
beatQueue.RegisterEvent(TimeService.CurrentBeatsTime + repeatBeatInterval, ReschedulingEvent(action, beatQueue, repeatBeatInterval));
}
/// <summary>
/// Registers a new event "<see cref="action"/>" that occurs on the next centibeat. 1/100 of a Beat
/// </summary>
/// <param name="beatQueue">The beat queue.</param>
/// <param name="action">The action to register.</param>
public static void RegisterOnNextCentiBeat(this IBeatsEventQueueRegisterable beatQueue, Action action)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
//This should basically fire instantly
//Registers the event to happen on the next beat.
beatQueue.RegisterEvent(TimeService.CurrentBeatsTime + ((1d - TimeService.CurrentBeatsTime % 0.01d)), action);
}
/// <summary>
/// Registers a new event "<see cref="action"/>" that occurs on the next beat.
/// </summary>
/// <param name="beatQueue">The beat queue.</param>
/// <param name="action">The action to register.</param>
public static void RegisterOnNextBeat(this IBeatsEventQueueRegisterable beatQueue, Action action)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
//Registers the event to happen on the next beat.
double beatsTimeWhole = (long)TimeService.CurrentBeatsTime;
beatQueue.RegisterEvent(beatsTimeWhole + 1d, action);
}
/// <summary>
/// Registers a new event "<see cref="action"/>" that occurs in <see cref="centiBeatCount"/> amount of centibeats.
/// </summary>
/// <param name="beatQueue">The beat queue.</param>
/// <param name="action">The action to register.</param>
/// <param name="centiBeatCount">The amount of centibeats that should pass before this event is dispatched</param>
public static void RegisterCentiBeatsFromNow(this IBeatsEventQueueRegisterable beatQueue, Action action, int centiBeatCount)
{
if (centiBeatCount < 0)
{
throw new ArgumentOutOfRangeException(nameof(centiBeatCount), "Registered beat time for event cannot be less than current time.");
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
beatQueue.RegisterEvent(TimeService.CurrentBeatsTime + (centiBeatCount / 100d), action);
}