--!strict --[[ Cooldown — per-player cooldowns and rate limits for abilities and remotes. SKLOP Studio · https://sklop.vercel.app · MIT License (free to use in any project) USAGE (server) local Cooldown = require(path.to.Cooldown) -- 1) Simple cooldown: one use every 0.5 s per player local swing = Cooldown.new(0.5) SwingRemote.OnServerEvent:Connect(function(player) if not swing:Try(player) then return -- still cooling down end doSwing(player) end) print(swing:Remaining(player)) -- seconds left (0 when ready) -- 2) Rate limit: bursts up to 10 calls, refilling at 5 per second local chatLimit = Cooldown.limiter(10, 5) if chatLimit:Allow(player) then ... end Player keys are cleaned up automatically when a player leaves. ]] local Players = game:GetService("Players") export type Cooldown = { Duration: number, Try: (self: Cooldown, key: any) -> boolean, Ready: (self: Cooldown, key: any) -> boolean, Remaining: (self: Cooldown, key: any) -> number, Reset: (self: Cooldown, key: any) -> (), Clear: (self: Cooldown, key: any) -> (), } export type Limiter = { Capacity: number, RefillPerSecond: number, Allow: (self: Limiter, key: any, cost: number?) -> boolean, Clear: (self: Limiter, key: any) -> (), } type Bucket = { tokens: number, updated: number } -- Every cooldown/limiter registers here so we can clean up leaving players. local registry: { [any]: boolean } = setmetatable({}, { __mode = "k" }) :: any local CooldownClass = {} CooldownClass.__index = CooldownClass local LimiterClass = {} LimiterClass.__index = LimiterClass local Module = {} --- A cooldown of `duration` seconds per key (usually a Player). function Module.new(duration: number): Cooldown assert(type(duration) == "number" and duration >= 0, "Cooldown.new expects a duration in seconds") local self = setmetatable({ Duration = duration, _readyAt = {} :: { [any]: number } }, CooldownClass) registry[self] = true return (self :: any) :: Cooldown end function CooldownClass.Ready(self: any, key: any): boolean local readyAt = self._readyAt[key] return readyAt == nil or os.clock() >= readyAt end function CooldownClass.Try(self: any, key: any): boolean if not CooldownClass.Ready(self, key) then return false end self._readyAt[key] = os.clock() + self.Duration return true end function CooldownClass.Remaining(self: any, key: any): number local readyAt = self._readyAt[key] if readyAt == nil then return 0 end return math.max(0, readyAt - os.clock()) end function CooldownClass.Reset(self: any, key: any) self._readyAt[key] = nil end CooldownClass.Clear = CooldownClass.Reset --- A token-bucket rate limiter: `capacity` calls at once, refilling `refillPerSecond`. function Module.limiter(capacity: number, refillPerSecond: number): Limiter assert(capacity > 0 and refillPerSecond > 0, "Cooldown.limiter expects positive numbers") local self = setmetatable({ Capacity = capacity, RefillPerSecond = refillPerSecond, _buckets = {} :: { [any]: Bucket }, }, LimiterClass) registry[self] = true return (self :: any) :: Limiter end function LimiterClass.Allow(self: any, key: any, cost: number?): boolean local price = cost or 1 local now = os.clock() local bucket: Bucket? = self._buckets[key] if not bucket then bucket = { tokens = self.Capacity, updated = now } self._buckets[key] = bucket end local b = bucket :: Bucket b.tokens = math.min(self.Capacity, b.tokens + (now - b.updated) * self.RefillPerSecond) b.updated = now if b.tokens < price then return false end b.tokens -= price return true end function LimiterClass.Clear(self: any, key: any) self._buckets[key] = nil end Players.PlayerRemoving:Connect(function(player) for object in registry do if object._readyAt then object._readyAt[player] = nil elseif object._buckets then object._buckets[player] = nil end end end) return Module