Guide · Spelardata

Så sparar du spelardata i Roblox Studio med DataStore

Roblox minns ingenting om en spelare mellan sessioner om inte ett serverskript har sparat det. I den här guiden bygger du en PlayerData-modul som laddar, håller i minnet och sparar varje spelares data via DataStoreService, och sedan går vi igenom test, gränser och hur sparad data går förlorad.

Uppdaterad 20 november 202617 min läsningSkriven av

I korthet

Använd DataStoreService från ett Script på servern: ladda spelarens data med GetAsync när hen ansluter, håll den i en tabell medan hen spelar, och spara med UpdateAsync på en timer, när spelaren lämnar (PlayerRemoving) och när servern stängs av (game:BindToClose). Lägg varje anrop i pcall och försök igen några gånger om det misslyckas.

  • För att testa i Studio, publicera din place och slå på File > Experience Settings > Security > Enable Studio Access to API Services i ett separat testspel: Studio använder samma data som de skarpa servrarna.
  • Om en spelares data inte laddades, spara aldrig den spelaren. Att spara standardvärden skriver över hens riktiga framsteg.
  • Spara en tabell per spelare under en nyckel, till exempel User_12345, och spara på timer, inte vid varje ändring.
  • För byteshandel eller betalda föremål, lägg till sessionslåsning så att två servrar inte kan spara samma spelare.
På den här sidan
  1. Studio-åtkomst
  2. Så fungerar DataStore
  3. GetAsync och UpdateAsync
  4. 1. PlayerData-modulen
  5. Så är modulen uppbyggd
  6. 2. Arbeta med datan
  7. 3. Varning
  8. 4. Test i Studio
  9. Varför data går förlorad
  10. Sessionslåsning
  11. Gränser
  12. Versioner och kopior
  13. Common errors
  14. With RoCode
  15. Vanliga frågor
  16. Källor och vidare läsning

Innan du börjar: slå på Studio-åtkomst i en testkopia

Ett spel som körs i Studio kan inte nå datalagren förrän du tillåter det. Tillåtelsen har en hake som Roblox dokumentation varnar för: Studio läser och skriver då samma datalager som det skarpa spelet, så ett test som nollställer dina mynt i Studio nollställer dem också i det skarpa spelet, och ett fel i testkoden kan förstöra riktiga spelares nycklar.

  1. Gör en testkopia. Spara din place till en fil, öppna kopian, välj File > Publish to Roblox As och klicka på Create new game. Lägg inte till den som en place i det skarpa spelet: alla places i samma spel delar samma datalager.
  2. I testkopian, öppna File > Experience Settings och gå till Security.
  3. Slå på Enable Studio Access to API Services och klicka på Save.

Anrop till datalager fungerar bara i Script på servern; ett LocalScript som försöker får ett fel, så klienter kan inte skriva sparad data. När en knapp ska ändra den ber klienten servern via en RemoteEvent, och servern bestämmer (se guiden om RemoteEvents, på engelska).

Så lagrar datalager spelardata

IllustrationTestet från steg 4 i guiden i snabbspolat läge: Play, Stop sparar sessionen i datalagret, ett nytt Play laddar den, så Output visar 200.

Ett datalager (data store) är en namngiven samling nycklar och värden på Roblox servrar, gemensam för alla servrar och alla places i ditt spel. DataStoreService:GetDataStore("PlayerData") returnerar ett sådant lager.

Roblox rekommendationer kokar ned till regeln ett lager för spelardata, en nyckel per spelare, en tabell i varje nyckel. Bygg nyckeln av spelarens UserId, till exempel User_12345, och aldrig av namnet, som hen kan byta. Ett fast mönster User_{UserId} gör också att Roblox automatiska hantering av rätten att bli bortglömd kan hitta spelarens data, om du ställer in den.

Vad du kan spara i ett datalager
TypSparas?Anmärkningar
Tal, strängar, booleska värden, buffertarJaSträngar måste vara giltig UTF-8. Spara inte inf eller nan.
TabellerJaOm allt inuti också kan sparas. En tabell vars numeriska nycklar inte börjar på 1 (så att dess längd är 0) kommer tillbaka med de nycklarna som strängar.
Instance, Vector3, CFrame, Color3NejSparningen ger ett fel eller skriver nil. Spara föremålets namn eller positionen som tre tal.

Varje förfrågan är ett webbanrop som kan misslyckas, tar tid och förbrukar en budget per minut. Därför läser pålitliga sparsystem datan en gång när spelaren ansluter, håller den i en servertabell medan hen spelar och skriver tillbaka den då och då.

GetAsync, SetAsync eller UpdateAsync: vilken ska du välja

Datalagrets viktigaste metoder
MetodVad den görTill vad
GetAsync(key)Läser värdet. Resultatet cachas på den här servern i 4 sekunder.Ladda spelardata
SetAsync(key, value)Skriver över värdet utan att läsa det. En skrivning.En ny nyckel eller ett värde som inte beror på det gamla
UpdateAsync(key, callback)Läser det senaste värdet, skickar det till din funktion och skriver det som den returnerar. En läsning och en skrivning.Spara spelardata och alla nycklar som flera servrar kan skriva
IncrementAsync(key, delta)Lägger till ett heltal till ett sparat heltal.Räknare
RemoveAsync(key)Tar bort nyckeln och returnerar det gamla värdet. Tidigare versioner kan fortfarande listas och läsas.Ta bort spelardata

SetAsync skriver i blindo: om två servrar sparar samma nyckel nästan samtidigt vinner den sista skrivningen, vad den än innehåller. UpdateAsync läser först det aktuella värdet, och om en annan server skriver under tiden kör Roblox din funktion igen med det nya värdet. Roblox rekommenderar den varje gång skrivningen beror på det aktuella värdet eller flera servrar kan skriva nyckeln, och det är precis vad spelardata är. Funktionen har tre regler:

  • Den får inte ge upp exekveringen (yield): ingen task.wait() och inga andra anrop till datalager inuti.
  • Den kan köras mer än en gång, så den ska bara räkna ut det nya värdet och aldrig dela ut föremål eller utlösa händelser.
  • Att returnera nil avbryter skrivningen. Modulen använder det för att inte skriva över data som sparats av en nyare version av spelet.

Steg 1: skapa PlayerData-modulen

Det här ModuleScript är den enda koden som pratar med datalagret. Den laddar spelarens data när hen ansluter, håller den i minnet, sparar var 180:e sekund, när spelaren lämnar och när servern stängs av, och vägrar spara spelare vars data inte laddades.

  1. I Explorer, håll muspekaren över ServerScriptService, klicka på + och infoga ett ModuleScript. Döp om det till PlayerData och ersätt innehållet med koden nedan.
  2. Ett ModuleScript körs bara när något skript hämtar det med require. Infoga i ServerScriptService ett Script med namnet Main och den här raden: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Andra serverskript hämtar det på samma sätt.
  3. Ändra DEFAULTS och typen Data efter ditt spel, och låt varje fält vara ett tal, en sträng, ett booleskt värde eller en tabell.
Explorer efter steg 1-3
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript i ServerScriptService med namnet PlayerData
-- PlayerData: laddar spelarens data när hen ansluter, håller den i minnet
-- och sparar på timer, när spelaren lämnar och när servern stängs av.
-- Andra serverskript läser och ändrar den via PlayerData.Get(player).

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

local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- höj när datans form ändras, och lägg till ett steg i migrate()
local AUTOSAVE_SECONDS = 180
-- I Studio ger ett misslyckat anrop upp direkt, så ett test utan åtkomst till lagret går snabbt
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- fördubblas efter varje misslyckande: 1, 2, 4

export type Data = {
	SchemaVersion: number,
	Coins: number,
	Level: number,
	Inventory: { string },
}

-- Vad en helt ny spelare börjar med
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- false om laddningen misslyckades: standarddata får inte ersätta riktiga framsteg
}

-- Anropas inuti varje pcall nedan, så en place som inte publicerats än
-- (utan åtkomst till lagret) ändå laddar spelare med standarddata
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- sparningar som fortfarande pågår, per nyckel
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- Utlöses med spelaren när dennes data är klar. Hämta tabellen med PlayerData.Get(player):
-- en tabell som skickas via BindableEvent kommer fram som en kopia, och att ändra den ändrar ingenting.
PlayerData.Loaded = loadedEvent.Event

local function deepCopy(value: any): any
	if type(value) ~= "table" then
		return value
	end
	local copy = {}
	for key, item in value do
		copy[key] = deepCopy(item)
	end
	return copy
end

local function defaultData(): Data
	local data = deepCopy(DEFAULTS) -- en ny kopia, så att spelare aldrig delar samma Inventory-tabell
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- Anpassar sparad data till det aktuella schemat. Returnerar nil om den inte kan användas säkert.
local function migrate(saved: any): Data?
	if type(saved) ~= "table" then
		return nil
	end
	local version = tonumber(saved.SchemaVersion) or 1
	if version > SCHEMA_VERSION then
		return nil -- sparad av en nyare version av spelet: ladda inte och skriv inte över här
	end

	-- Ett steg per schemaändring, från äldst till nyast
	if version < 2 then
		-- Exempel: i version 1 hette valutan Gold. Kopiera den bara om Coins saknas,
		-- så att gammal data som redan har Coins men saknar SchemaVersion behåller sitt värde.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Lägg till fält som tillkommit sedan spelarens senaste sparning och ersätt värden av fel typ
	for field, default in DEFAULTS do
		if type(saved[field]) ~= type(default) then
			saved[field] = deepCopy(default)
		end
	end
	saved.SchemaVersion = SCHEMA_VERSION
	return saved
end

-- Kör ett anrop mot lagret i pcall. Vid misslyckande väntar den och försöker igen, och fördubblar
-- väntan varje gång plus lite slump, så att servrarna inte försöker igen alla på en gång.
local function withRetries(label: string, call: () -> any): (boolean, any)
	for attempt = 1, MAX_ATTEMPTS do
		local ok, result = pcall(call)
		if ok then
			return true, result
		end
		warn(`{label} failed (attempt {attempt} of {MAX_ATTEMPTS}): {result}`)
		if attempt < MAX_ATTEMPTS then
			local waitTime = FIRST_RETRY_SECONDS * 2 ^ (attempt - 1)
			task.wait(waitTime + math.random() * waitTime / 2)
		end
	end
	return false, nil
end

local function save(session: Session): boolean
	if not session.canSave then
		return false
	end
	local key = session.key
	pendingSaves[key] = (pendingSaves[key] or 0) + 1

	local newerSchema = false
	local ok = withRetries(`Save {key}`, function()
		return store():UpdateAsync(key, function(current: any)
			if type(current) == "table" and (tonumber(current.SchemaVersion) or 1) > SCHEMA_VERSION then
				newerSchema = true
				return nil -- att returnera nil avbryter skrivningen
			end
			-- Skriv hela den aktuella tabellen, märkt med spelarens UserId
			return session.data, { session.userId }
		end)
	end)

	local left = (pendingSaves[key] or 1) - 1
	if left > 0 then
		pendingSaves[key] = left
	else
		pendingSaves[key] = nil
	end
	if newerSchema then
		session.canSave = false
		warn(`{key} was saved by a newer version of the game, so this server stopped saving it`)
	end
	return ok and not newerSchema
end

local function startAutosave(player: Player, session: Session)
	task.spawn(function()
		-- Börja vid en slumpmässig punkt i intervallet, så att servrarna inte sparar alla på en gång
		task.wait(math.random() * AUTOSAVE_SECONDS)
		while sessions[player] == session do
			save(session)
			task.wait(AUTOSAVE_SECONDS)
		end
	end)
end

local function load(player: Player)
	local key = "User_" .. player.UserId

	-- Om spelaren just lämnade den här servern och kom tillbaka, låt först den senaste sparningen bli klar
	while pendingSaves[key] do
		task.wait()
	end

	local ok, saved = withRetries(`Load {key}`, function()
		return store():GetAsync(key)
	end)
	if player.Parent ~= Players then
		return -- lämnade under laddningen: inget ändrades, inget att spara
	end

	local data: Data? = nil
	if ok then
		data = if saved == nil then defaultData() else migrate(saved)
	end

	local session: Session = {
		key = key,
		userId = player.UserId,
		data = data or defaultData(),
		canSave = data ~= nil,
	}
	if not session.canSave then
		warn(`Could not load {key}. {player.Name} is playing on default data that will not be saved.`)
	end

	sessions[player] = session
	player:SetAttribute("DataLoaded", session.canSave) -- ett GUI kan läsa detta och varna spelaren
	startAutosave(player, session)
	loadedEvent:Fire(player)
end

local function endSession(player: Player)
	local session = sessions[player]
	if not session then
		return
	end
	sessions[player] = nil -- stoppar autosparningsloopen, och ett andra anrop gör ingenting
	save(session)
end

-- Spelarens levande datatabell, eller nil tills den har laddats. Ändra den bara från serverskript.
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True när spelarens data har laddats och kommer att sparas. Kontrollera före varje försäljning.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Sparar nu, utan att vänta på timern, för viktiga ögonblick som ett köp.
-- Väntar (yield) och returnerar true när sparningen lyckades.
function PlayerData.SaveNow(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and save(session)
end

Players.PlayerAdded:Connect(load)
Players.PlayerRemoving:Connect(endSession)
for _, player in Players:GetPlayers() do
	task.spawn(load, player) -- spelare som anslöt innan den här modulen först kördes med require
end

game:BindToClose(function()
	-- Servern ger de här funktionerna 30 sekunder, så vi sparar alla samtidigt
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Vänta sedan på alla sparningar som fortfarande pågår, även de som startade i PlayerRemoving
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

När spelet har släppts, ändra inte STORE_NAME eller nyckelmönstret User_. Om du ändrar något av dem pekar modulen på tomma nycklar, och varje spelare börjar om från standardvärdena.

Så skyddar modulen datan

Standardvärden och schemaversion

En ny spelare får en ny kopia av DEFAULTS. Det måste vara just en kopia: om alla spelare delade samma Inventory-tabell skulle ett föremål som läggs till hos en spelare dyka upp hos alla.

Varje sparad tabell bär på SchemaVersion. Att lägga till ett fält kräver ingen ny version, eftersom migrate fyller i fält som saknas från standardvärdena. Att byta namn eller bygga om gör det: höj SCHEMA_VERSION och lägg till ett steg, som i exemplet som byter namn på Gold till Coins (i ett nytt spel tar du bort det och börjar på 1). Data med en högre version än serverns kommer från en nyare release som fortfarande rullas ut, så äldre servrar rör den inte.

En misslyckad laddning sparas aldrig

Den här regeln skyddar mot att allt raderas. Om alla laddningsförsök misslyckades spelar spelaren på standarddata, men canSave är false, så de värdena skriver aldrig över hens riktiga framsteg. Modulen sätter också attributet DataLoaded till false, och steg 3 använder det för att säga till spelaren. Roblox referensexempel hanterar misslyckade laddningar på samma sätt och föreslår det i stället för en kick; om du hellre kickar, anropa player:Kick() med ett meddelande där modulen skriver ut varningen.

Omförsök med ökande paus

withRetries lägger varje anrop i pcall. Efter ett misslyckande väntar den 1, sedan 2, sedan 4 sekunder, varje gång plus slumpmässigt upp till halva den tiden, och slutar efter fyra försök (i Studio efter ett, så att en place utan åtkomst till lagret startar direkt). Slumpen sprider ut omförsöken från många servrar efter ett avbrott, och gränsen håller väntan inom ungefär 10 sekunder, inom de 30 sekunder som servern får vid avstängning. Eftersom varje sparning skriver hela den levande tabellen via UpdateAsync kan ett omförsök som blir klart sent inte återställa gammal data.

När modulen sparar

NärVarför
Var 180:e sekund medan spelaren är på servernBegränsar förlusten vid en krasch. Den första sparningen sker vid en slumpmässig punkt i intervallet, så att servrarna inte sparar alla på en gång. Roblox referensexempel använder också 180 sekunder.
När spelaren lämnar (PlayerRemoving)Den vanliga sista sparningen. Sessionen tas bort först, så autosparningen stannar.
När servern stängs av (game:BindToClose)Alla som fortfarande är på servern sparas på en gång, och funktionen väntar på varje pågående sparning. Roblox ger den 30 sekunder.
På begäran, via PlayerData.SaveNow(player)Efter något som inte får gå förlorat, till exempel ett köp.

Om spelaren ansluter till samma server igen medan hens sista sparning fortfarande pågår väntar den nya laddningen tills den sparningen är klar, så den kan inte läsa det gamla värdet.

Steg 2: läs och ändra datan från andra skript

Alla serverskript som hämtar modulen med require arbetar med samma tabeller:

AnropVad det gör
PlayerData.Get(player)Spelarens levande datatabell, eller nil tills den har laddats. Ändra fälten direkt, till exempel data.Coins += 10, så tar nästa sparning med det.
PlayerData.LoadedUtlöses med spelaren när dennes data är klar, även efter en misslyckad laddning. Skickar bara spelaren, eftersom en tabell som skickas via BindableEvent kommer fram som en kopia.
PlayerData.CanSave(player)false om laddningen misslyckades. Kontrollera före varje försäljning: ett köp som inte kan sparas försvinner när spelaren lämnar.
PlayerData.SaveNow(player)Sparar direkt och returnerar true om det lyckades. Väntar (yield).

Modulen är det enda stället där sparad data bor, och leaderstats är bara en visning: bygg den som i guiden om topplistor (leaderboard), fyll den från PlayerData.Get(player) i Loaded-hanteraren och uppdatera båda när ett värde ändras. Läs aldrig tillbaka sparade värden från leaderstats, och låt aldrig ett andra skript spara samma nyckel.

Ett skript som hämtar modulen efter att spelare redan har anslutit missar Loaded för dem. Anslut hanteraren och loopa sedan också igenom Players:GetPlayers() och hantera alla som PlayerData.Get(player) redan returnerar en tabell för.

Byter du ut ett gammalt sparskript, till exempel från guiden om topplistor? Dess värden ligger kvar i dess eget lager och dess egen nyckel, så den här modulen startar alla från standardvärdena. Innan lanseringen, peka antingen STORE_NAME och prefixet User_ mot de gamla (migrate behandlar data utan SchemaVersion som version 1 och fyller i fält som saknas), eller flytta över de gamla värdena och ta sedan bort det gamla skriptet.

Klienter ändrar aldrig den här datan direkt. En butiksknapp utlöser en RemoteEvent; servern kontrollerar CanSave, jämför priset med spelarens Coins, ändrar tabellen och anropar SaveNow. Guiden om butiks-GUI bygger ett sådant köp på serversidan.

Ett färdigt exempel på att lägga till fält finns i guiden om klickersimulatorer: den lägger till PowerLevel och Rebirths i DEFAULTS och typen Data, och ändrar dem sedan i tabellen som PlayerData.Get returnerar. migrate ger de nya fälten till spelare med gamla sparningar.

Steg 3: säg till spelaren att datan inte laddades

En spelare vars data inte laddades behöver veta att den här sessionen inte sparas, så att hen ansluter igen i stället för att spela i onödan. Det här LocalScript bevakar attributet DataLoaded och visar en banner när det är false.

LocalScript i StarterPlayerScripts med namnet DataWarning
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local shown = false

local function showWarning()
	if shown or player:GetAttribute("DataLoaded") ~= false then
		return
	end
	shown = true

	local gui = Instance.new("ScreenGui")
	gui.Name = "DataWarning"
	gui.ResetOnSpawn = false

	local label = Instance.new("TextLabel")
	label.AnchorPoint = Vector2.new(0.5, 0)
	label.Position = UDim2.new(0.5, 0, 0, 12)
	label.Size = UDim2.new(0.8, 0, 0, 48)
	label.BackgroundColor3 = Color3.fromRGB(110, 28, 28)
	label.TextColor3 = Color3.new(1, 1, 1)
	label.TextScaled = true
	label.Text = "Your saved progress could not be loaded. Nothing you do in this server will be saved, so rejoin later."
	label.Parent = gui

	gui.Parent = player:WaitForChild("PlayerGui")
end

-- Servern sätter DataLoaded en gång, efter försöket att ladda den här spelarens data
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

Steg 4: testa sparningen i Studio

Gör det här i testkopian med Studio-åtkomst påslagen.

  1. Ge dig själv något att spara. Under require-raden i Main, lägg till: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Tryck på Play. Output-fönstret (i menyn Window eller på fliken Script) visar ditt namn och 100 (första gången), utan varningen Could not load.
  3. Tryck på Stop. När testet avslutas stängs servern, och modulen sparar dig innan den stängs.
  4. Tryck på Play igen. Output ska visa 200, 100 mer än förra gången. Om den visar samma tal igen gick sparningen inte igenom: läs varningarna ovanför.
  5. Testa felvägen. Stäng av Studio-åtkomsten och tryck på Play. Efter några sekunders omförsök visar Output Could not load User_... och 100, och bannern från steg 3 dyker upp. Stoppa testet, slå på åtkomsten igen och tryck på Play: Output visar 300, dina sparade 200 plus 100, eftersom den misslyckade sessionen aldrig skrev över din data.
  6. Ta bort testraden från Main.

Varför spelardata går förlorad

Här är de vanliga sätten som ett sparsystem tappar framsteg på. Modulen täcker de fyra första raderna och raden om schemat i koden; resten beror på vad och hur du sparar, och den sista kräver sessionslåsning.

Vad som händerResultatSå förhindrar du det
Laddningen misslyckades, men skriptet sparar ändåStandardvärden skriver över riktiga framsteg: allt raderasSpara aldrig en spelare vars laddning misslyckades
Sparar bara i PlayerRemovingEn krasch eller avstängning av servern hoppar över sparningenAutosparning plus BindToClose som väntar på sina sparningar
Ingen pcall eller inget omförsökEn misslyckad förfrågan stoppar skriptet eller tappar en sparningpcall med flera omförsök utspridda i tid
Sparar vid varje ändringFörfrågningar ställs i kö; när kön har 30 kastas nyaHåll datan i minnet och spara på timer
Sparar något som lagret inte kan lagraSparningen ger ett fel, eller värdet kommer tillbaka som nilSpara tal, strängar, booleska värden och tabeller av dem
Ändrar datans form utan migreringGamla sparningar laddas in i fel fältSchemaversion och ett migreringssteg
Två skript sparar samma nyckelVarje sparning skriver över den andras fältEn modul äger nyckeln
Två servrar håller samma spelareServern med gammal data sparar sist och skriver över nya framstegSessionslåsning

Sessionslåsning, "lock lost" och ProfileStore

En spelare är ansluten till en server i taget, men den gamla serverns sista sparning kan fortfarande pågå när hen ansluter till en ny: ett långsamt omförsök, en teleport eller en snabb återanslutning. Om den nya servern laddar datan först får den gammal data, och den server som sparar sist vinner. Roblox dokumentation påpekar att det här glappet är en vanlig orsak till duplicerade föremål i spel med byteshandel.

Sessionslåsning stänger det glappet. När en server laddar spelarens nyckel skriver den i samma UpdateAsync-anrop sitt lås-ID i nyckelns metadata. Varje annan server som hittar ett lås som inte har gått ut och som den inte själv satte laddar och sparar inte den nyckeln. Ägaren förnyar låset vid varje autosparning och släpper det i den sista sparningen; om den slutar förnya det går låset ut, och en annan server kan ta det.

Vad "lock lost" betyder

I ett system med sessionslåsning har en server förlorat låset när en annan server nu äger spelarens nyckel, eftersom låset gick ut eller togs över. Dess kopia kan vara inaktuell, så den måste sluta spara den spelaren; den vanliga reaktionen är att kicka hen med ett meddelande om att ansluta igen. Om du såg "lock lost" som spelare är det ett meddelande från det spelets eget sparsystem, och bara dess utvecklare kan förklara det.

Behöver du det?

Modulen i den här guiden låser inte sessioner. Utan lås är det verkliga värsta fallet följande: i en sällsynt kapplöpning förlorar spelaren det hen tjänat på den gamla servern efter dess senaste lyckade sparning. Lägg till låsning när duplicering eller förlust kostar spelarna något på riktigt: byteshandel, developer products, sällsynta föremål eller täta teleporter.

AlternativVad det ärBra att veta
Modulen i den här guidenLaddning, cache i minnet, omförsök, autosparning, sparning vid avstängning och schemaversioner, utan låsningKort nog att läsa i sin helhet och ändra
Roblox exempel för spelardata och köpReferenskod från Roblox med sessionslåsning, omförsök i ordning för varje nyckel och hantering av kvitton för köpRoblox säger att det inte är beprövat i ett populärt spel och inte ska användas som det är utan omfattande tester
ProfileStoreEn gratis communitymodul med öppen källkod, efterföljare till ProfileService, byggd kring sessionslåsning och autosparningInte från Roblox. Att flytta ett befintligt spel till den kräver migrering av redan sparad data

För alla moduler från tredje part råder Roblox dig att kontrollera vem som äger den, om den underhålls och hur du kommer åt din data utan den. Samma dokumentation kallar DataStore2 ett föråldrat bibliotek som nya spel inte bör använda.

Gränser för datalager

Det här är gränserna från Roblox dokumentation per den 30 september 2026. Roblox ser över dem, så kontrollera sidan om felkoder och gränser (på engelska) innan du räknar med ett exakt tal.

Standardgränser för förfrågningar per server, per minut
Typ av förfråganVanliga lagerOrdnade lager
Läsning: GetAsync, läsningen i UpdateAsync60 + 40 × spelare60 + 40 × spelare
Skrivning: SetAsync, IncrementAsync, skrivningen i UpdateAsync60 + 40 × spelare30 + 5 × spelare
Lista: ListKeysAsync eller GetSortedAsync för ordnade lager5 + 2 × spelare5 + 2 × spelare
Borttagning: RemoveAsync60 + 40 × spelare30 + 5 × spelare

Med 20 spelare kan en server göra 860 vanliga skrivningar per minut; den här modulens autosparning använder ungefär 7 av dem, plus en för varje spelare som lämnar. Det som tömmer budgeten är att spara vid varje upplockat mynt. En andra budget gäller för hela spelet och delas med Open Cloud: 300 läsningar per minut plus 40 per spelare online, och 300 skrivningar plus 20 per spelare.

Gränser för storlek och genomströmning
GränsVärde
Lagrets namn, nyckelns namn, scope50 tecken vardera
Värdet i en nyckel4 194 304 tecken som JSON
Läsning av en nyckel från alla servrar25 MB per minut
Skrivning till en nyckel från alla servrar4 MB per minut, varje förfrågan avrundas uppåt till nästa KB
Väntande förfrågningar30 per kö; utöver det misslyckas förfrågningar med felen 301-306
Lagring för hela spelet500 MB plus 1 MB för varje användare genom tiderna

Mät storleken på en spelares data med #HttpService:JSONEncode(data), och se den skarpa serverns återstående budget med DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite). GetAsync-anrop som besvarades av cachen på 4 sekunder räknas inte. Run-läget i Studio har egna, möjligen lägre gränser, så för att testa gränserna för förfrågningar rekommenderar Roblox Team Create.

Versioner och säkerhetskopior

Vanliga datalager sparar historiken åt dig. Den första skrivningen till en nyckel varje timme i UTC sparas som en version, och senare skrivningar samma timme skriver över varandra. En gammal version går ut 30 dagar efter att en nyare skrivning ersatte den; den senaste går aldrig ut. Ordnade lager sparar inga versioner.

För att återställa en enskild spelare, öppna Data Stores Manager (Creations, ditt spel, Configure > Data Stores Manager), välj hens nyckel, välj en tidigare version och klicka på Revert; det kräver behörigheten Edit. Gör det medan spelaren är offline, annars sparar servern med hens session sin kopia ovanpå återställningen. Från ett serverskript hittar och läser ListVersionsAsync och GetVersionAsync en gammal version, som du sedan skriver tillbaka som det aktuella värdet.

Innan du publicerar en uppdatering som ändrar hur data sparas råder Roblox dig att ta en ögonblicksbild via Open Cloud Snapshot Data Stores API (en per dag och spel). Utan den skriver en felaktig sparning klockan 3:30 UTC över allt som skrevs till den nyckeln sedan 3:00, eftersom den hamnar i samma timversion.

Vanliga fel och lösningar

Fel från datalager syns i Output-fönstret i Studio, och modulen skriver ut en varning med Roblox feltext vid varje misslyckat försök. Guiden om skriptfel förklarar hur man läser Output över huvud taget.

StudioAccessToApisNotAllowed (fel 403)

"Can't write to DataStore from Studio because API access is not enabled." Publicera din place och slå sedan på Enable Studio Access to API Services i File > Experience Settings > Security, i testkopian.

DataStore request was added to queue

Servern skickar förfrågningar snabbare än budgeten tillåter, eller skriver samma nyckel för ofta, oftast för att den sparar vid varje ändring eller i en loop. När kön har 30 förfrågningar misslyckas nya med felen 301-306. Håll datan i minnet och spara på timer.

CantStoreValue (fel 104), eller ett fält kommer tillbaka som nil

Tabellen innehåller något som lagret inte kan spara, till exempel en Instance, Vector3 eller Color3. Spara i stället ett namn, ett ID eller enkla tal och bygg upp objektet igen vid laddningen.

ValueTooLarge (fel 105)

En nyckel innehåller mer än 4 194 304 tecken JSON. Mät med #HttpService:JSONEncode(data), ta bort det som kan byggas upp igen, eller dela upp datan på flera fasta nycklar.

Inga fel, men datan sparas inte

Leta efter modulens varning Could not load: efter en misslyckad laddning vägrar den med flit att spara. Annars ändrades värdet troligen i ett LocalScript, vilket aldrig når servern, eller så sparar ett annat skript samma nyckel.

Datan nollställs varje gång jag ansluter igen

Nyckeln ändras mellan sessionerna (byggd av player.Name, eller så ändrade du STORE_NAME), laddningen misslyckas och du ser standardvärdena, eller så hämtar inget skript modulen med require, och den körs inte alls. Kontrollera Output och att Main hämtar PlayerData.

Bygg det med RoCode

Om du inte vill bygga det här för hand kan RoCode göra det direkt i den place du har öppen. Det är en oberoende AI-agent, inte från Roblox, som arbetar via ett plugin för Roblox Studio: den skriver Luau som använder DataStoreService som vilket skript som helst och skapar skripten i din Explorer. Själv rör den aldrig dina datalager, men med plugin 3.9 eller nyare kan den trycka på Play för ett kort speltest, där dina skript körs som i vilket test som helst.

Du skriver

Lägg till sparning i mitt spel: spara Coins, Level och Inventory i en PlayerData-modul med autosparning och sparning när servern stängs av, och visa Coins i de leaderstats som jag redan har.

RoCode gör
  • Kan söka efter befintliga leaderstats och DataStore-kod med Search Scripts och Read Script, för att bygga vidare på det du har i stället för att lägga till ett andra sparskript. I en stor place, nämn skriptet eller mappen i meddelandet.
  • Skapar ett ModuleScript och ett Script som hämtar det med Create Script, eller ändrar befintliga med Edit Script
  • Kör Check Script för varje skript den skriver: en kompileringskontroll i Studio med en kort lista varningar, inte en typkontroll och inte en testkörning
  • Skickar ändringarna i omgångar, och varje omgång är en ångrapunkt (undo) i Studio

Att slå på Studio Access to API Services i testkopian måste du fortfarande göra själv: RoCode kan inte ändra den inställningen. Med plugin 3.9 eller nyare läser dess korta speltest fel, och med plugin 3.9.11 eller nyare kan den styra en testfigur för att kontrollera att spelet fungerar, men den kontrollerar bara det den själv valt att kontrollera, så spela själv och se till att Coins, Level och Inventory sparas och laddas. Om sparningen inte gick igenom i ditt test kan Check Output läsa Server-raderna från speltestet du körde. Sparning läggs oftast till när spelets grundloop redan fungerar; att skapa ett Roblox-spel med AI ett system i taget visar den ordningen. Så ansluter RoCode till Studio.

Vanliga frågor

Hur slår man på DataStore i Roblox Studio?

Publicera din place, öppna File > Experience Settings > Security, slå på Enable Studio Access to API Services och klicka på Save. Gör det i ett separat testspel, eftersom Studio då använder samma datalager som spelets skarpa servrar.

Sparar Roblox spelardata automatiskt?

Nej. Ingenting om en spelare sparas efter sessionen om inte ett serverskript sparar det via DataStoreService, och det gäller leaderstats också.

Vad ska jag välja: ProfileStore eller DataStoreService direkt?

ProfileStore bygger också på datalager, så frågan är om du vill att sessionslåsningen skrivs och underhålls åt dig. För byteshandel, betalda föremål eller täta teleporter är låsning värd det, från ett bibliotek eller Roblox referensexempel. För ett mindre spel är en modul som den här enklare att läsa och ändra.

Hur nollställer eller tar man bort en spelares data?

I Data Stores Manager, hitta nyckeln och välj Mark for Deletion, vilket kan ångras under väntetiden, eller anropa RemoveAsync på nyckeln från ett serverskript. Gör det medan spelaren är offline, annars skriver hens servers nästa sparning tillbaka datan. I testkopian startar alla från noll om du byter STORE_NAME; gör aldrig det i det skarpa spelet.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.