How to use a debounce in Roblox

-- Script inside a Part. Step on it once and count the prints.
local pad = script.Parent :: BasePart

pad.Touched:Connect(function(hit: BasePart)
	print("Touched by", hit.Name)
end)

-- Script inside a Part named Trap.
-- Drops a ball when anyone steps on it, then waits 3 seconds before it can fire again.
local trap = script.Parent :: BasePart

local RESET_SECONDS = 3

local busy = false

trap.Touched:Connect(function(hit: BasePart)
	if busy then
		return
	end
	local humanoid = hit.Parent and hit.Parent:FindFirstChildOfClass("Humanoid")
	if not humanoid then
		return -- not a character: do not start the cooldown for a loose part
	end
	busy = true

	local ball = Instance.new("Part")
	ball.Shape = Enum.PartType.Ball
	ball.Size = Vector3.new(4, 4, 4)
	ball.Position = trap.Position + Vector3.new(0, 30, 0)
	ball.Parent = workspace
	game:GetService("Debris"):AddItem(ball, 5)

	task.wait(RESET_SECONDS)
	busy = false
end)

-- Script inside a Part named CoinPad.
-- Gives coins on touch, at most once every COOLDOWN_SECONDS per player.
local Players = game:GetService("Players")

local pad = script.Parent :: BasePart

local COOLDOWN_SECONDS = 5
local COINS = 10

local lastPaid: { [Player]: number } = {}

pad.Touched:Connect(function(hit: BasePart)
	local character = hit.Parent
	local player = if character and character:IsA("Model") then Players:GetPlayerFromCharacter(character) else nil
	if not player then
		return -- an NPC or a loose part
	end
	local now = os.clock()
	if now - (lastPaid[player] or 0) < COOLDOWN_SECONDS then
		return -- this player was paid recently
	end
	lastPaid[player] = now

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if coins and coins:IsA("IntValue") then
		coins.Value += COINS
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastPaid[player] = nil -- do not keep players who left
end)

-- ModuleScript in ServerScriptService named Cooldown.
-- Cooldown.try(player, "Dash", 2) returns true at most once every 2 seconds for that player and action.
local Players = game:GetService("Players")

local Cooldown = {}

local lastUse: { [Player]: { [string]: number } } = {}

function Cooldown.try(player: Player, action: string, seconds: number): boolean
	local now = os.clock()
	local actions = lastUse[player]
	if not actions then
		actions = {}
		lastUse[player] = actions
	end
	local last = actions[action]
	if last and now - last < seconds then
		return false
	end
	actions[action] = now
	return true
end

function Cooldown.remaining(player: Player, action: string, seconds: number): number
	local actions = lastUse[player]
	local last = actions and actions[action]
	if not last then
		return 0
	end
	return math.max(seconds - (os.clock() - last), 0)
end

Players.PlayerRemoving:Connect(function(player: Player)
	lastUse[player] = nil
end)

return Cooldown

-- Script in ServerScriptService named DashServer.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

type CooldownModule = {
	try: (Player, string, number) -> boolean,
	remaining: (Player, string, number) -> number,
}
local Cooldown = require(ServerScriptService:WaitForChild("Cooldown")) :: CooldownModule

local DASH_COOLDOWN = 2
local dashRemote = ReplicatedStorage:WaitForChild("Dash") :: RemoteEvent

dashRemote.OnServerEvent:Connect(function(player: Player)
	if not Cooldown.try(player, "Dash", DASH_COOLDOWN) then
		return -- too soon: ignore silently
	end
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	if root and root:IsA("BasePart") then
		root.AssemblyLinearVelocity += root.CFrame.LookVector * 60
	end
end)