Obby Template: Tower of Hell-Style Obstacle Course

-- ServerScriptService/CheckpointSystem.server.luau

local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

local progressStore = DataStoreService:GetDataStore("ObbyProgress_v1")
local stagesFolder = workspace:WaitForChild("Stages")

-- In-memory state per player
local playerCheckpoints: { [Player]: { stage: number, checkpoint: number, spawnCFrame: CFrame } } = {}

local function getSpawnCFrame(checkpointPart: BasePart): CFrame
    return checkpointPart.CFrame + Vector3.new(0, 4, 0)
end

-- Load saved progress when a player joins
local function onPlayerAdded(player: Player)
    local savedStage = 1
    local savedCheckpoint = 0

    local success, data = pcall(function()
        return progressStore:GetAsync("player_" .. player.UserId)
    end)

    if success and data then
        savedStage = data.stage or 1
        savedCheckpoint = data.checkpoint or 0
    end

    -- Find the spawn position for the saved checkpoint
    local stageFolder = stagesFolder:FindFirstChild("Stage_" .. savedStage)
    local spawnCFrame = CFrame.new(0, 10, 0) -- fallback

    if stageFolder then
        local checkpointsFolder = stageFolder:FindFirstChild("Checkpoints")
        if checkpointsFolder and savedCheckpoint > 0 then
            local cp = checkpointsFolder:FindFirstChild("Checkpoint_" .. savedCheckpoint)
            if cp then
                spawnCFrame = getSpawnCFrame(cp)
            end
        else
            local firstCp = checkpointsFolder and checkpointsFolder:FindFirstChild("Checkpoint_1")
            if firstCp then
                spawnCFrame = getSpawnCFrame(firstCp)
            end
        end
    end

    playerCheckpoints[player] = {
        stage = savedStage,
        checkpoint = savedCheckpoint,
        spawnCFrame = spawnCFrame,
    }

    -- Teleport player to their saved checkpoint on first spawn
    player.CharacterAdded:Connect(function(character)
        local hrp = character:WaitForChild("HumanoidRootPart")
        task.wait(0.1) -- let physics settle
        local state = playerCheckpoints[player]
        if state then
            hrp.CFrame = state.spawnCFrame
        end
    end)
end

-- ServerScriptService/ObstacleManager.server.luau
-- OBSTACLE TYPE 3: Disappearing Platforms

local function setupDisappearingPlatforms()
    for _, stageFolder in stagesFolder:GetChildren() do
        local obstacles = stageFolder:FindFirstChild("Obstacles")
        if not obstacles then continue end

        for _, part: BasePart in obstacles:GetDescendants() do
            if not part:IsA("BasePart") or not part.Name:match("^Disappear_") then continue end

            part.Anchored = true
            local originalTransparency = part.Transparency
            local originalColor = part.Color

            -- Configurable timing via attributes
            local fadeDelay = part:GetAttribute("FadeDelay") or 0.5
            local disappearDuration = part:GetAttribute("DisappearDuration") or 3

            local isActive = true

            part.Touched:Connect(function(hit)
                if not isActive then return end

                local player = Players:GetPlayerFromCharacter(hit.Parent)
                if not player then return end

                isActive = false

                -- Warning flash: turn red briefly
                part.Color = Color3.fromRGB(255, 80, 80)
                task.wait(fadeDelay)

                -- Fade out
                local fadeTween = TweenService:Create(part, TweenInfo.new(0.3), {
                    Transparency = 1,
                })
                fadeTween:Play()
                fadeTween.Completed:Wait()

                part.CanCollide = false

                -- Wait then reappear
                task.wait(disappearDuration)

                part.CanCollide = true
                part.Color = originalColor
                local reappearTween = TweenService:Create(part, TweenInfo.new(0.3), {
                    Transparency = originalTransparency,
                })
                reappearTween:Play()
                reappearTween.Completed:Wait()

                isActive = true
            end)
        end
    end
end

-- ServerScriptService/LeaderboardManager.server.luau

-- Submit a time (only saves if it beats the player's previous best)
local function submitTime(player: Player, stageNumber: number, timeSeconds: number)
    local store = getStageLeaderboard(stageNumber)
    local key = "player_" .. player.UserId
    local timeMs = math.floor(timeSeconds * 1000)

    pcall(function()
        store:UpdateAsync(key, function(oldValue)
            if oldValue == nil or timeMs < oldValue then
                return timeMs
            end
            return oldValue
        end)
    end)
end

-- Fetch top times for a stage
local function getTopTimes(stageNumber: number): { { userId: number, timeMs: number } }
    local store = getStageLeaderboard(stageNumber)
    local results = {}

    local success, pages = pcall(function()
        return store:GetSortedAsync(true, LEADERBOARD_SIZE)
    end)

    if success and pages then
        local entries = pages:GetCurrentPage()
        for _, entry in entries do
            local odString = entry.key or ""
            local odUserId = tonumber(odString:match("player_(%d+)"))
            table.insert(results, {
                userId = odUserId,
                timeMs = entry.value,
            })
        end
    end

    return results
end

Build me a 50-stage space-themed obby. Stages 1–20 are on a space station,
stages 21–40 are in zero-gravity asteroid fields, and stages 41–50 are inside
a black hole with neon obstacles. Add a speedrun timer and global leaderboard.