How to use Roblox DataStore the right way (with AI)

Files Picoo ships for this prompt

1 file · 155 lines · one recipe call

Sample output: ServerScriptService/PlayerDataServer.lua

--!strict
-- Generated by Picoo recipe: datastore_save
-- Persists Coins per player with pcall + retry + BindToClose

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

-- GetDataStore itself errors in a place that was never published, and can in
-- Studio without API access. Called bare up here, that one error stopped this
-- whole script before anyone joined. Now a failure only leaves the store nil:
-- every load fails at once, so a Studio play test runs on in memory and saves
-- nothing, and a save (only ever after a load that succeeded) always has it.
local storeOk, storeResult = pcall(function()
	return DataStoreService:GetDataStore("PlayerData_v1")
end)
local STORE: DataStore? = if storeOk then storeResult else nil
local STORE_ERROR: string? = if storeOk then nil else tostring(storeResult)
local DEFAULT_VALUE = 0
local AUTOSAVE_INTERVAL = 60

-- Retry helper: 3 attempts with exponential backoff. pcall wraps every
-- DataStore call so transient network failures don't crash the server.
local function safe<T>(fn: (...any) -> T, ...): (T?, string?)
	local args = {...}
	for attempt = 1, 3 do
		local ok, result: any = pcall(fn, table.unpack(args))
		if ok then return result, nil end
		if attempt < 3 then task.wait(2 ^ attempt) end
		if attempt == 3 then return nil, tostring(result) end
	end
	return nil, "unreachable"
end

-- (excerpt) the save state, saving a player, and the shutdown handler:

-- In-memory cache so reads don't hit DataStore on every change
local cache: { [number]: number } = {}
local dirty: { [number]: boolean } = {}
-- true ONLY after a load that succeeded. A failed load is never saved over:
-- saving the default would replace the player's real data with it.
local loaded: { [number]: boolean } = {}
-- One write per player at a time: two writes in flight can land in either
-- order, so the retry of an older value could land last and put it back.
-- saving[userId] is the ticket of the write in flight; activeSaves counts the
-- saves still waiting or writing, so BindToClose can wait for all of them.
local saving: { [number]: number } = {}
local nextTicket = 0
local activeSaves = 0

local function savePlayer(player: Player)
	if not loaded[player.UserId] then return end -- never overwrite after a failed load
	activeSaves += 1
	-- A write already in flight for this player: wait for it (at most 10 s),
	-- then write whatever is newest.
	local waited = 0
	while saving[player.UserId] and waited < 10 do
		waited += task.wait(0.1)
	end
	local key = "u_" .. player.UserId
	local value = cache[player.UserId]
	if dirty[player.UserId] and value ~= nil then
		nextTicket += 1
		local ticket = nextTicket
		saving[player.UserId] = ticket
		local overtaken = false
		local _, err = safe(function(): string?
			-- A newer write took over while this one waited to retry (it stopped
			-- waiting after 10 s): stop here, or this older value would land last.
			if saving[player.UserId] ~= ticket then
				overtaken = true
				return nil
			end
			return (STORE :: DataStore):SetAsync(key, value)
		end)
		-- Released after a failure too, unless a newer write already owns it.
		if saving[player.UserId] == ticket then saving[player.UserId] = nil end
		if err then
			warn("[DataStore] save failed for " .. player.Name .. ": " .. err)
		elseif not overtaken and cache[player.UserId] == value then
			-- Only if nothing changed while SetAsync yielded: a newer value stays
			-- dirty, so the next autosave, the leave save or the shutdown save writes it.
			dirty[player.UserId] = false
		end
	end
	activeSaves -= 1
end

-- BindToClose runs on server shutdown so no in-flight progress is lost
game:BindToClose(function()
	for _, player in ipairs(Players:GetPlayers()) do
		task.spawn(savePlayer, player)
	end
	-- Stay until every save has finished, leave saves included, but never
	-- past Roblox's 30-second limit for shutdown.
	local waited = 0
	repeat
		waited += task.wait(0.25)
	until activeSaves == 0 or waited >= 25
end)