local Utils = {} function Utils.CreateIntervalScheduler(Library, RunService, adapter) adapter = adapter or {} local intervalState = { workers = {}, tokens = {}, slowWarns = {}, } local DEFAULT_INTERVAL_MIN_DELAY = 0.03 local SLOW_INTERVAL_WARN_SEC = 10 local SLOW_INTERVAL_WARN_COOLDOWN = 5 local function getIntervalDelay(delayTime, minDelay) local value = delayTime if type(value) == "function" then local ok, result = pcall(value) if not ok then return nil, "Delay provider failed." end value = result end value = delayTime == nil and 0.1 or tonumber(value) local minimum = minDelay == nil and DEFAULT_INTERVAL_MIN_DELAY or tonumber(minDelay) if not value or value ~= value or math.abs(value) == math.huge then return nil, "Delay must be a finite number." end if not minimum or minimum ~= minimum or math.abs(minimum) == math.huge or minimum < 0 then return nil, "Minimum delay must be a finite nonnegative number." end return math.max(value, minimum) end local function isIntervalFlagEnabled(flagName) if flagName == nil or flagName == "" then return true end if type(flagName) == "function" then local ok, result = pcall(flagName) return ok and result == true end local value = Library.Flags[flagName] return value ~= nil and value ~= false end local function cleanupIntervalTag(tag) Library:CleanupConnectionsByTag(tag) end local function trackIntervalConnection(conn, tag) local ok, err = pcall(Library.TrackConnection, Library, conn, tag) if not ok then conn:Disconnect() error(err, 0) end end local function interval(tag, flagName, delayTime, callback, options) options = type(options) == "table" and options or {} tag = tostring(tag or ("Interval_" .. tostring(flagName or "Always"))) if type(callback) ~= "function" then return nil end cleanupIntervalTag(tag) intervalState.tokens[tag] = (intervalState.tokens[tag] or 0) + 1 local token = intervalState.tokens[tag] local persistent = options.persistent if not persistent and not isIntervalFlagEnabled(flagName) then return nil end if intervalState.tokens[tag] ~= token then return nil end local fixedDelay, fixedError if type(delayTime) ~= "function" then fixedDelay, fixedError = getIntervalDelay(delayTime, options.minDelay) if not fixedDelay then warn("[Versus interval]", tag, fixedError) return nil end end local last = os.clock() local conn local function isCurrent() return conn.Connected and intervalState.tokens[tag] == token and (not adapter.isCurrent or adapter.isCurrent()) end local function settingsAreReady() return type(Library.IsInitializing) ~= "function" or not Library:IsInitializing() end conn = RunService.Heartbeat:Connect(function() if not isCurrent() or not settingsAreReady() then return end local enabled = isIntervalFlagEnabled(flagName) if not isCurrent() then return end if not enabled then if not persistent then intervalState.tokens[tag] += 1 cleanupIntervalTag(tag) end return end if intervalState.workers[tag] then return end local currentDelay, delayError = fixedDelay, fixedError if type(delayTime) == "function" then currentDelay, delayError = getIntervalDelay(delayTime, options.minDelay) end if not isCurrent() or intervalState.workers[tag] then return end if not currentDelay then intervalState.tokens[tag] += 1 cleanupIntervalTag(tag) warn("[Versus interval]", tag, delayError) return end local current = os.clock() local delta = current - last if delta < currentDelay then return end last = current -- A running callback retains this tag until it finishes, even across replacement. local worker = {} intervalState.workers[tag] = worker local runWorker = function() local callbackStartedAt, callbackDuration local ok, err = pcall(function() if not isCurrent() or not settingsAreReady() or not isIntervalFlagEnabled(flagName) or not isCurrent() then return end local startedAt = os.clock() callbackStartedAt = startedAt if adapter.invoke then adapter.invoke(tag, flagName, callback, delta, isCurrent) else callback(delta) end local elapsed = os.clock() - startedAt callbackDuration = elapsed if elapsed >= SLOW_INTERVAL_WARN_SEC then local lastWarn = intervalState.slowWarns[tag] or 0 if os.clock() - lastWarn >= SLOW_INTERVAL_WARN_COOLDOWN then intervalState.slowWarns[tag] = os.clock() warn(string.format("[Versus] slow interval %s took %.3fs", tag, elapsed)) end end end) if callbackStartedAt and adapter.observe and not intervalState.observerError then local observed, observerError = pcall( adapter.observe, tag, flagName, callbackDuration or math.max(0, os.clock() - callbackStartedAt), ok ) if not observed then intervalState.observerError = tostring(observerError) warn("[Versus interval] Timing observer stopped:", intervalState.observerError) end end if intervalState.workers[tag] == worker then intervalState.workers[tag] = nil end if not ok then warn("[Versus interval]", tag, err) end end if adapter.spawn then adapter.spawn(tag, runWorker) else task.spawn(runWorker) end end) trackIntervalConnection(conn, tag) if adapter.track then adapter.track(conn) end return conn end return interval, intervalState, trackIntervalConnection end return Utils.CreateIntervalScheduler