Tutorial · Spillerdata

Slik lagrer du spillerdata i Roblox Studio med DataStore

Roblox husker ingenting om en spiller mellom økter hvis et serverskript ikke har lagret det. I denne guiden bygger du en PlayerData-modul som laster inn, holder i minnet og lagrer dataene til hver spiller med DataStoreService, og så går vi gjennom testing, grenser og hvordan lagrede data går tapt.

Oppdatert 20. november 202618 min lesingSkrevet av

Kort fortalt

Bruk DataStoreService fra et server-Script: last inn spillerens data med GetAsync når han kommer inn, hold dem i en tabell mens han spiller, og lagre med UpdateAsync på en tidtaker, når han går (PlayerRemoving) og når serveren slås av (game:BindToClose). Pakk hvert kall inn i pcall og prøv mislykkede kall på nytt noen ganger.

  • For å teste i Studio publiserer du placet og slår på File > Experience Settings > Security > Enable Studio Access to API Services i et eget testspill: Studio bruker de samme dataene som de ekte serverne.
  • Hvis spillerens data ikke ble lastet inn, skal du aldri lagre den spilleren. Å lagre standardverdier overskriver den ekte fremgangen hans.
  • Lagre én tabell per spiller under én nøkkel, for eksempel User_12345, og lagre på en tidtaker, ikke ved hver endring.
  • For bytte av gjenstander eller betalte gjenstander legger du til øktlås, så to servere ikke kan lagre den samme spilleren.
På denne siden
  1. Studio-tilgang
  2. Slik virker DataStore
  3. GetAsync og UpdateAsync
  4. 1. PlayerData-modulen
  5. Slik er modulen bygd
  6. 2. Jobbe med dataene
  7. 3. Advarsel
  8. 4. Test i Studio
  9. Hvorfor data går tapt
  10. Øktlås
  11. Grenser
  12. Versjoner og kopier
  13. Common errors
  14. With RoCode
  15. Ofte stilte spørsmål
  16. Kilder og videre lesing

Før du starter: slå på Studio-tilgang i en testkopi

Et spill som kjører i Studio, har ikke tilgang til data stores før du tillater det. Tillatelsen har en felle som dokumentasjonen til Roblox advarer om: Studio leser og skriver da de samme data stores som det ekte spillet, så en test som nullstiller myntene dine i Studio, nullstiller dem også i det ekte spillet, og en feil i testkode kan ødelegge nøklene til ekte spillere.

  1. Lag en testkopi. Lagre placet til en fil, åpne kopien, velg File > Publish to Roblox As og klikk på Create new game. Ikke legg den til som et place inne i det ekte spillet: alle places i ett spill deler de samme data stores.
  2. Åpne File > Experience Settings i testkopien og gå til Security.
  3. Slå på Enable Studio Access to API Services og klikk på Save.

Kall til data stores virker bare i server-Script; et LocalScript som prøver, får en feil, så klienter kan ikke skrive lagrede data. Når en knapp skal endre dem, ber klienten serveren om det via en RemoteEvent, og serveren bestemmer (se guiden til RemoteEvents).

Slik lagrer data stores spillerdata

IllustrasjonTesten fra steg 4 i guiden i raskere tempo: Play, Stop lagrer økten i data store, en ny Play laster den inn, så Output viser 200.

En data store er en navngitt samling nøkler og verdier på serverne til Roblox, felles for alle servere og alle places i spillet ditt. DataStoreService:GetDataStore("PlayerData") returnerer én slik data store.

Anbefalingene fra Roblox koker ned til regelen én data store for spillerdata, én nøkkel per spiller, én tabell i hver nøkkel. Lag nøkkelen fra spillerens UserId, for eksempel User_12345, og aldri fra navnet, som han kan endre. Et fast mønster User_{UserId} lar også den automatiske behandlingen til Roblox av retten til å bli glemt finne spillerens data, hvis du setter den opp.

Hva du kan lagre i en data store
TypeLagres?Merknader
Tall, strenger, boolske verdier, buffereJaStrenger må være gyldig UTF-8. Ikke lagre inf eller nan.
TabellerJaHvis alt inni også kan lagres. En tabell der tallnøklene ikke starter på 1 (så lengden er 0), kommer tilbake med disse nøklene som strenger.
Instance, Vector3, CFrame, Color3NeiLagringen gir en feil eller skriver nil. Lagre navnet på gjenstanden, eller posisjonen som tre tall.

Hver forespørsel er et nettkall som kan mislykkes, tar tid og bruker av et budsjett per minutt. Derfor leser pålitelige lagringssystemer dataene én gang når spilleren kommer inn, holder dem i en servertabell mens han spiller, og skriver dem tilbake av og til.

GetAsync, SetAsync eller UpdateAsync: hva skal du velge

De viktigste metodene i en data store
MetodeHva den gjørTil hva
GetAsync(key)Leser en verdi. Resultatet caches på denne serveren i 4 sekunder.Innlasting av spillerdata
SetAsync(key, value)Overskriver en verdi uten å lese den. Én skriving.En ny nøkkel eller en verdi som ikke avhenger av den gamle
UpdateAsync(key, callback)Leser den nyeste verdien, sender den til funksjonen din og skriver det den returnerer. Én lesing og én skriving.Lagring av spillerdata og alle nøkler som flere servere kan skrive
IncrementAsync(key, delta)Legger et heltall til et lagret heltall.Tellere
RemoveAsync(key)Sletter en nøkkel og returnerer den gamle verdien. Tidligere versjoner kan fortsatt listes opp og leses.Sletting av spillerdata

SetAsync skriver i blinde: hvis to servere lagrer den samme nøkkelen nesten samtidig, vinner den siste skrivingen, uansett hva den inneholder. UpdateAsync leser først den gjeldende verdien, og hvis en annen server skriver i mellomtiden, kjører Roblox funksjonen din på nytt med den nye verdien. Roblox anbefaler den alltid når skrivingen avhenger av den gjeldende verdien eller flere servere kan skrive nøkkelen, og det er akkurat spillerdata. Funksjonen har tre regler:

  • Den må ikke gi fra seg kjøringen (yield): ingen task.wait() og ingen andre kall til data stores inni.
  • Den kan kjøre mer enn én gang, så den skal bare regne ut den nye verdien og aldri dele ut gjenstander eller utløse hendelser.
  • Å returnere nil avbryter skrivingen. Modulen bruker dette for å ikke overskrive data som en nyere versjon av spillet har lagret.

Steg 1: lag PlayerData-modulen

Dette ModuleScript-et er den eneste koden som snakker med data store. Det laster inn spillerens data når han kommer inn, holder dem i minnet, lagrer hvert 180. sekund, når han går og når serveren slås av, og nekter å lagre dem som ikke fikk dataene sine lastet inn.

  1. Hold musen over ServerScriptService i Explorer, klikk på + og sett inn et ModuleScript. Gi det nytt navn, PlayerData, og bytt ut innholdet med koden nedenfor.
  2. Et ModuleScript kjører bare når et skript henter det inn (require). Sett inn et Script med navnet Main i ServerScriptService med denne linjen: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Andre serverskript henter det inn på samme måte.
  3. Endre DEFAULTS og typen Data så de passer spillet ditt, og la hvert felt være et tall, en streng, en boolsk verdi eller en tabell.
Explorer etter steg 1-3
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript i ServerScriptService med navnet PlayerData
-- PlayerData: laster inn spillerens data når han kommer inn, holder dem i minnet
-- og lagrer på en tidtaker, når han går og når serveren slås av.
-- Andre serverskript leser og endrer dem 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 -- øk når formen på dataene endres, og legg til et steg i migrate()
local AUTOSAVE_SECONDS = 180
-- I Studio gir et mislykket kall opp med en gang, så en test uten tilgang til data store går raskt
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- dobles etter hver feil: 1, 2, 4

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

-- Det en helt ny spiller starter med
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- false hvis innlastingen mislyktes: standarddata skal ikke erstatte ekte fremgang
}

-- Kalles inne i hvert pcall nedenfor, så et place som ennå ikke er publisert
-- (uten tilgang til data store) likevel laster inn spillere med standarddata
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- lagringer som fortsatt pågår, per nøkkel
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- Utløses med spilleren når dataene hans er klare. Hent tabellen med PlayerData.Get(player):
-- en tabell sendt via BindableEvent kommer fram som en kopi, og å endre den endrer 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 fersk kopi, så spillere aldri deler én Inventory-tabell
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- Bringer lagrede data opp til gjeldende skjema. Returnerer nil hvis de ikke kan brukes trygt.
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 -- lagret av en nyere versjon av spillet: ikke last inn og ikke overskriv her
	end

	-- Ett steg per skjemaendring, fra eldst til nyest
	if version < 2 then
		-- Eksempel: i versjon 1 het valutaen Gold. Vi kopierer den bare hvis Coins mangler,
		-- så gamle data som allerede har Coins, men ikke SchemaVersion, beholder verdien.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Legger til felt som kom etter spillerens siste lagring, og bytter ut verdier av feil type
	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

-- Kjører et kall til data store i pcall. Ved feil venter den og prøver igjen, og dobler
-- ventetiden hver gang og legger til litt tilfeldighet, så servere ikke prøver på nytt samtidig.
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 -- å returnere nil avbryter skrivingen
			end
			-- Skriver hele den gjeldende tabellen, merket med spillerens 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()
		-- Starter på et tilfeldig tidspunkt i intervallet, så servere ikke lagrer samtidig
		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

	-- Hvis spilleren nettopp gikk fra denne serveren og kom tilbake, lar vi først den siste lagringen bli ferdig
	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 -- gikk under innlastingen: ingenting er endret, ingenting å lagre
	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) -- et GUI kan lese dette og advare spilleren
	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 -- stopper autolagringsløkken, og et nytt kall gjør ingenting
	save(session)
end

-- Den levende datatabellen til spilleren, eller nil til den er lastet inn. Endre den bare fra serverskript.
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True når spillerens data er lastet inn og vil bli lagret. Sjekk før ethvert salg.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Lagrer nå, uten å vente på tidtakeren, for viktige øyeblikk som et kjøp.
-- Gir fra seg kjøringen og returnerer true når lagringen gikk gjennom.
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) -- spillere som kom inn før denne modulen ble hentet inn første gang
end

game:BindToClose(function()
	-- Serveren gir disse funksjonene 30 sekunder, så vi lagrer alle samtidig
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Så venter vi på alle lagringer som fortsatt pågår, også dem som startet i PlayerRemoving
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

Når spillet er lansert, ikke endre STORE_NAME eller nøkkelmønsteret User_. Å endre noen av dem sender modulen til tomme nøkler, og hver spiller starter på nytt med standardverdiene.

Slik beskytter modulen dataene

Standardverdier og skjemaversjon

En ny spiller får en fersk kopi av DEFAULTS. Det må være en kopi: hvis alle spillere delte én Inventory-tabell, ville en gjenstand som ble lagt til hos én, dukket opp hos alle.

Hver lagret tabell har en SchemaVersion. Å legge til et felt krever ikke en ny versjon, fordi migrate fyller inn manglende felt fra standardverdiene. Å gi nytt navn eller bygge om krever det: øk SCHEMA_VERSION og legg til et steg, som i eksemplet som gir Gold nytt navn til Coins (i et nytt spill sletter du det og starter på 1). Data med høyere versjon enn serveren sin kommer fra en nyere utgivelse som fortsatt rulles ut, så eldre servere rører dem ikke.

En mislykket innlasting lagres aldri

Denne regelen beskytter mot full sletting. Hvis alle innlastingsforsøk mislyktes, spiller spilleren på standarddata, men canSave er false, så disse verdiene overskriver aldri den ekte fremgangen hans. Modulen setter også attributten DataLoaded til false, og steg 3 bruker den til å si fra til spilleren. Referanseeksemplet til Roblox håndterer mislykkede innlastinger på samme måte og foreslår dette i stedet for å kaste ut spilleren; hvis du heller vil kaste ut, kaller du player:Kick() med en melding der modulen skriver advarselen.

Nye forsøk med økende pause

withRetries pakker hvert kall inn i pcall. Etter en feil venter den 1, så 2, så 4 sekunder, hver gang pluss tilfeldig opptil halvparten av den tiden, og stopper etter fire forsøk (i Studio etter ett, så et place uten tilgang til data store starter med en gang). Tilfeldigheten sprer de nye forsøkene fra mange servere etter et brudd, og grensen holder ventingen innenfor omtrent 10 sekunder, innenfor de 30 sekundene serveren får når den slås av. Fordi hver lagring skriver hele den levende tabellen med UpdateAsync, kan ikke et nytt forsøk som blir ferdig for sent, bringe tilbake gamle data.

Når modulen lagrer

NårHvorfor
Hvert 180. sekund mens spilleren er på serverenBegrenser tapet ved et krasj. Den første lagringen kommer på et tilfeldig tidspunkt i intervallet, så servere ikke lagrer samtidig. Referanseeksemplet til Roblox bruker også 180 sekunder.
Når spilleren går (PlayerRemoving)Den vanlige siste lagringen. Økten fjernes først, så autolagringen stopper.
Når serveren slås av (game:BindToClose)Alle som fortsatt er på serveren, lagres samtidig, og funksjonen venter på hver lagring som pågår. Roblox gir den 30 sekunder.
Ved behov, med PlayerData.SaveNow(player)Etter noe som ikke må gå tapt, for eksempel et kjøp.

Hvis spilleren kommer inn på samme server igjen mens den siste lagringen hans fortsatt pågår, venter den nye innlastingen til den lagringen er ferdig, så den kan ikke lese en gammel verdi.

Steg 2: les og endre dataene fra andre skript

Alle serverskript som henter inn modulen, jobber med de samme tabellene:

KallHva det gjør
PlayerData.Get(player)Den levende datatabellen til spilleren, eller nil til den er lastet inn. Endre feltene direkte, for eksempel data.Coins += 10, og neste lagring tar det med.
PlayerData.LoadedUtløses med spilleren når dataene hans er klare, også etter en mislykket innlasting. Sender bare spilleren, fordi en tabell sendt via BindableEvent kommer fram som en kopi.
PlayerData.CanSave(player)false hvis innlastingen mislyktes. Sjekk før ethvert salg: et kjøp som ikke kan lagres, forsvinner når spilleren går.
PlayerData.SaveNow(player)Lagrer med en gang og returnerer true hvis det gikk. Gir fra seg kjøringen.

Modulen er det eneste stedet de lagrede dataene bor, og leaderstats er bare visning: bygg den som i guiden til leaderboard, fyll den fra PlayerData.Get(player) i Loaded-behandleren og oppdater begge når en verdi endres. Les aldri lagrede verdier tilbake fra leaderstats, og la aldri et annet skript lagre den samme nøkkelen.

Et skript som henter inn modulen etter at spillerne kom inn, går glipp av Loaded for dem. Koble til behandleren, og gå så i tillegg gjennom Players:GetPlayers() i en løkke og behandle alle der PlayerData.Get(player) allerede returnerer en tabell.

Erstatter du et gammelt lagringsskript, for eksempel fra guiden til leaderboard? Verdiene i det blir værende i dets egen data store og nøkkel, så denne modulen starter alle med standardverdiene. Før lansering peker du enten STORE_NAME og prefikset User_ mot de gamle (migrate regner data uten SchemaVersion som versjon 1 og fyller inn manglende felt), eller flytter de gamle verdiene over og sletter så det gamle skriptet.

Klienter endrer aldri disse dataene direkte. En butikknapp utløser en RemoteEvent; serveren sjekker CanSave, sammenligner prisen med spillerens Coins, endrer tabellen og kaller SaveNow. Guiden til butikk-GUI bygger et slikt kjøp på serversiden.

Et ferdig eksempel på å legge til felt finner du i guiden til clicker-simulator: den legger til PowerLevel og Rebirths i DEFAULTS og typen Data, og endrer dem så i tabellen som PlayerData.Get returnerer. migrate gir de nye feltene til spillere med gamle lagringer.

Steg 3: si fra til spilleren at dataene ikke ble lastet inn

En spiller der dataene ikke ble lastet inn, må vite at denne økten ikke blir lagret, så han kan komme inn på nytt i stedet for å spille forgjeves. Dette LocalScript-et følger med på attributten DataLoaded og viser et banner når den er false.

LocalScript i StarterPlayerScripts med navnet 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

-- Serveren setter DataLoaded én gang, etter forsøket på å laste inn dataene til denne spilleren
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

Steg 4: test lagringen i Studio

Gjør dette i testkopien med Studio-tilgang slått på.

  1. Gi deg selv noe å lagre. Under require-linjen i Main legger du til: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Trykk på Play. Vinduet Output (i menyen Window eller på fanen Script) viser navnet ditt og 100 (første gang), uten advarselen Could not load.
  3. Trykk på Stop. Å avslutte testen lukker serveren, og modulen lagrer deg før den lukkes.
  4. Trykk på Play igjen. Output skal vise 200, 100 mer enn forrige gang. Hvis den viser det samme tallet igjen, gikk ikke lagringen gjennom: les advarslene over det.
  5. Test feilveien. Slå av Studio-tilgang og trykk på Play. Etter noen sekunder med nye forsøk viser Output Could not load User_... og 100, og banneret fra steg 3 dukker opp. Stopp testen, slå på tilgangen igjen og trykk på Play: Output viser 300, dine lagrede 200 pluss 100, fordi den mislykkede økten aldri overskrev dataene dine.
  6. Slett testlinjen fra Main.

Hvorfor spillerdata går tapt

Dette er de vanlige måtene et lagringssystem mister fremgang på. Modulen dekker de fire første radene og raden om skjema i koden; resten avhenger av hva og hvordan du lagrer, og den siste krever øktlås.

Hva som skjerResultatSlik forhindrer du det
Innlastingen mislyktes, men skriptet lagrer likevelStandardverdier overskriver ekte fremgang: full slettingAldri lagre en spiller der innlastingen mislyktes
Lagring bare i PlayerRemovingEt krasj eller en avslutning av serveren hopper over lagringenAutolagring pluss BindToClose som venter på sine lagringer
Ingen pcall eller ingen nye forsøkÉn mislykket forespørsel stopper skriptet eller mister en lagringpcall med noen nye forsøk spredt i tid
Lagring ved hver endringForespørsler havner i kø; når køen har 30, forkastes nyeHolde dataene i minnet og lagre på en tidtaker
Lagring av noe data store ikke kan lagreLagringen gir en feil, eller verdien kommer tilbake som nilLagre tall, strenger, boolske verdier og tabeller av dem
Endring av formen på dataene uten migreringGamle lagringer lastes inn i feil feltSkjemaversjon og et migreringssteg
To skript lagrer den samme nøkkelenHver lagring overskriver feltene til det andreÉn modul eier nøkkelen
To servere holder den samme spillerenServeren med gamle data lagrer sist og overskriver ny fremgangØktlås

Øktlås, «lock lost» og ProfileStore

En spiller er koblet til én server om gangen, men den siste lagringen på den gamle serveren kan fortsatt pågå når han kommer inn på en ny: et tregt nytt forsøk, en teleport eller en rask ny innlogging. Hvis den nye serveren laster inn dataene først, får den gamle data, og serveren som lagrer sist, vinner. Dokumentasjonen til Roblox nevner at dette hullet er en vanlig årsak til duplisering av gjenstander i spill med bytte.

Øktlås tetter dette hullet. Når en server laster inn nøkkelen til en spiller, skriver den sin lås-ID i nøkkelens metadata i samme UpdateAsync-kall. Enhver annen server som finner en lås som ikke har utløpt og som den ikke har satt selv, verken laster inn eller lagrer den nøkkelen. Eieren fornyer låsen ved hver autolagring og fjerner den i den siste lagringen; hvis den slutter å fornye den, utløper låsen, og en annen server kan ta den.

Hva «lock lost» betyr

I et system med øktlås har en server mistet låsen når en annen server nå eier spillerens nøkkel, fordi låsen utløp eller ble tatt over. Kopien dens kan være utdatert, så den må slutte å lagre den spilleren; den vanlige reaksjonen er å kaste ham ut med en melding, så han kobler til på nytt. Hvis du så «lock lost» som spiller, er det en melding fra det spillets eget lagringssystem, og bare utviklerne av spillet kan forklare den.

Trenger du det?

Modulen i denne guiden låser ikke økter. Uten lås er det reelle verste tilfellet slik: i et sjeldent kappløp mister spilleren det han tjente på den gamle serveren etter den siste vellykkede lagringen der. Legg til lås når duplisering eller tap koster spillerne noe ekte: bytte, developer products, sjeldne gjenstander eller hyppige teleporter.

AlternativHva det erVerdt å vite
Modulen i denne guidenInnlasting, cache i minnet, nye forsøk, autolagring, lagring ved avslutning og skjemaversjoner, uten låsKort nok til å lese i sin helhet og endre
Roblox sitt eksempel for spillerdata og kjøpReferansekode fra Roblox med øktlås, nye forsøk i rekkefølge for hver nøkkel og behandling av kjøpskvitteringerRoblox sier at den ikke er testet over tid i et populært spill og ikke bør brukes som den er uten omfattende testing
ProfileStoreEn gratis modul fra fellesskapet med åpen kildekode, etterfølgeren til ProfileService, bygd rundt øktlås og autolagringIkke fra Roblox. Å flytte et eksisterende spill over til den krever migrering av data som allerede er lagret

For enhver tredjepartsmodul anbefaler Roblox å sjekke hvem som eier den, om den vedlikeholdes, og hvordan du kommer til dataene dine uten den. Den samme dokumentasjonen kaller DataStore2 et utdatert bibliotek som nye spill ikke bør bruke.

Grenser for data stores

Dette er grensene fra dokumentasjonen til Roblox per 30. september 2026. Roblox endrer dem, så sjekk siden med feilkoder og grenser (på engelsk) før du baserer deg på et nøyaktig tall.

Standardgrenser for forespørsler per server, per minutt
Type forespørselVanlige data storesOrdered data stores
Lesing: GetAsync, lesing i UpdateAsync60 + 40 × spillere60 + 40 × spillere
Skriving: SetAsync, IncrementAsync, skriving i UpdateAsync60 + 40 × spillere30 + 5 × spillere
Liste: ListKeysAsync eller GetSortedAsync for ordered data stores5 + 2 × spillere5 + 2 × spillere
Sletting: RemoveAsync60 + 40 × spillere30 + 5 × spillere

Med 20 spillere kan en server gjøre 860 vanlige skrivinger i minuttet; autolagringen i denne modulen bruker rundt 7 av dem, pluss én for hver spiller som går. Budsjettet brukes opp av lagring ved hver mynt som plukkes opp. Et annet budsjett gjelder hele spillet og deles med Open Cloud: 300 lesinger i minuttet pluss 40 for hver spiller som er pålogget, og 300 skrivinger pluss 20 per spiller.

Grenser for størrelse og gjennomstrømning
GrenseVerdi
Navn på data store, navn på nøkkel, scope50 tegn hver
Verdien i én nøkkel4 194 304 tegn som JSON
Lesing av én nøkkel fra alle servere25 MB i minuttet
Skriving til én nøkkel fra alle servere4 MB i minuttet, hver forespørsel rundes opp til neste KB
Ventende forespørsler30 per kø; utover det feiler forespørsler med feil 301-306
Lagringsplass for hele spillet500 MB pluss 1 MB for hver bruker gjennom tidene

Mål størrelsen på spillerens data med #HttpService:JSONEncode(data), og se det gjenværende budsjettet til en ekte server med DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite). GetAsync-kall som ble besvart av cachen på 4 sekunder, telles ikke. Run-modus i Studio har egne, kanskje lavere grenser, så for å teste grenser for forespørsler anbefaler Roblox Team Create.

Versjoner og sikkerhetskopier

Vanlige data stores tar vare på historikken for deg. Den første skrivingen til en nøkkel i hver time etter UTC lagres som en versjon, og senere skrivinger i den timen overskriver hverandre. En gammel versjon utløper 30 dager etter at en nyere skriving erstattet den; den siste utløper aldri. Ordered data stores lagrer ikke versjoner.

For å rulle tilbake én spiller åpner du Data Stores Manager (Creations, spillet ditt, Configure > Data Stores Manager), velger nøkkelen hans, velger en tidligere versjon og klikker på Revert; det krever Edit-rettighet. Gjør det mens spilleren ikke er pålogget, ellers lagrer serveren med økten hans sin kopi over tilbakerullingen. Fra et serverskript finner og leser ListVersionsAsync og GetVersionAsync en gammel versjon, som du så skriver tilbake som gjeldende verdi.

Før du publiserer en oppdatering som endrer hvordan data lagres, anbefaler Roblox å ta et øyeblikksbilde med Open Cloud Snapshot Data Stores API (ett per dag per spill). Uten det vil en feilaktig lagring kl. 3:30 UTC overskrive alt som ble skrevet til den nøkkelen siden 3:00, fordi den havner i den samme timesversjonen.

Vanlige feil og løsninger

Feil fra data stores dukker opp i vinduet Output i Studio, og modulen skriver en advarsel med feilteksten fra Roblox ved hvert mislykket forsøk. Guiden til skriptfeil forklarer hvordan du leser Output generelt.

StudioAccessToApisNotAllowed (feil 403)

«Can't write to DataStore from Studio because API access is not enabled.» Publiser placet, og slå så på Enable Studio Access to API Services i File > Experience Settings > Security, i testkopien.

DataStore request was added to queue

Serveren sender forespørsler raskere enn budsjettet tillater, eller skriver én nøkkel for ofte, som regel på grunn av lagring ved hver endring eller i en løkke. Når køen har 30 forespørsler, feiler nye med feil 301-306. Hold dataene i minnet og lagre på en tidtaker.

CantStoreValue (feil 104), eller et felt kommer tilbake som nil

Tabellen inneholder noe data store ikke kan lagre, for eksempel Instance, Vector3 eller Color3. Lagre i stedet et navn, en ID eller enkle tall, og bygg objektet opp igjen ved innlasting.

ValueTooLarge (feil 105)

Én nøkkel inneholder mer enn 4 194 304 tegn JSON. Mål med #HttpService:JSONEncode(data), fjern det som kan bygges opp igjen, eller del dataene på flere faste nøkler.

Ingen feil, men dataene lagres ikke

Se etter advarselen Could not load fra modulen: etter en mislykket innlasting nekter den med vilje å lagre. Ellers ble verdien mest sannsynlig endret i et LocalScript, og det når aldri serveren, eller et annet skript lagrer den samme nøkkelen.

Dataene nullstilles hver gang jeg kommer inn igjen

Nøkkelen endres mellom økter (bygd fra player.Name, eller du endret STORE_NAME), innlastingen mislykkes og du ser standardverdiene, eller ingen henter inn modulen, så den kjører ikke i det hele tatt. Sjekk Output og at Main henter inn PlayerData.

Bygg det med RoCode

Hvis du ikke har lyst til å bygge dette for hånd, kan RoCode gjøre det rett i placet du har åpent. Det er en uavhengig AI-agent, ikke fra Roblox, som jobber via en plugin for Roblox Studio: den skriver Luau som bruker DataStoreService som ethvert skript, og lager skriptene i Explorer. Selv går den aldri inn i dine data stores, men med plugin 3.9 eller nyere kan den trykke på Play for en kort playtest der skriptene dine kjører som i enhver test.

Du skriver

Legg til lagring i spillet mitt: lagre Coins, Level og Inventory i en PlayerData-modul med autolagring og lagring når serveren slås av, og vis Coins i leaderstats som jeg allerede har.

RoCode gjør
  • Kan søke etter eksisterende leaderstats og DataStore-kode med Search Scripts og Read Script for å utvide det du har, i stedet for å legge til et nytt lagringsskript. I et stort place kan du nevne skriptet eller mappen i meldingen.
  • Lager ModuleScript-et og et Script som henter det inn med Create Script, eller endrer eksisterende med Edit Script
  • Kjører Check Script for hvert skript den skriver: en kompileringssjekk inne i Studio med en kort liste over advarsler, ikke en typesjekk og ikke en testkjøring
  • Sender endringene i runder, og hver runde er et angrepunkt (undo) i Studio

Å slå på Studio Access to API Services i testkopien må du fortsatt gjøre selv: RoCode kan ikke endre den innstillingen. Med plugin 3.9 eller nyere leser den korte playtesten feil, og med plugin 3.9.11 eller nyere kan den styre en testkarakter for å sjekke at spillet virker, men den sjekker bare det den selv har valgt å sjekke, så spill selv og forsikre deg om at Coins, Level og Inventory lagres og lastes inn. Hvis lagringen ikke gikk gjennom i testen din, kan Check Output lese Server-linjene fra playtesten du startet. Lagring legges vanligvis til når den grunnleggende spilløkken allerede virker; lage et Roblox-spill med AI, ett system om gangen viser den rekkefølgen. Slik kobler RoCode seg til Studio.

Ofte stilte spørsmål

Hvordan slår jeg på DataStore i Roblox Studio?

Publiser placet, åpne File > Experience Settings > Security, slå på Enable Studio Access to API Services og klikk på Save. Gjør det i et eget testspill, fordi Studio da bruker de samme data stores som de ekte serverne til det spillet.

Lagrer Roblox spillerdata automatisk?

Nei. Ingenting om en spiller lagres etter økten hvis et serverskript ikke lagrer det med DataStoreService, og det gjelder leaderstats også.

Hva skal jeg velge: ProfileStore eller DataStoreService direkte?

ProfileStore er også bygd på data stores, så spørsmålet er om du vil at øktlåsen skal skrives og vedlikeholdes for deg. For bytte, betalte gjenstander eller hyppige teleporter er låsen verdt det, fra et bibliotek eller fra referanseeksemplet til Roblox. For et mindre spill er en modul som denne enklere å lese og endre.

Hvordan nullstiller eller sletter jeg dataene til en spiller?

Finn nøkkelen i Data Stores Manager og velg Mark for Deletion, som kan angres i løpet av venteperioden, eller kall RemoveAsync for nøkkelen fra et serverskript. Gjør det mens spilleren ikke er pålogget, ellers skriver neste lagring fra serveren hans dataene tilbake. I testkopien starter alle fra null hvis du endrer STORE_NAME; gjør aldri det i det ekte spillet.

Kilder og videre lesing

Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.

Prøv RoCode i ditt eget spill.

Gratis credits hver dag, uten kort. Installer pluginen, beskriv en funksjon og se hva som dukker opp i Studio.