Tutorial · Spillerdata

Sådan gemmer du spillerdata i Roblox Studio med DataStore

Roblox husker intet om en spiller mellem sessioner, medmindre et server-script har gemt det. I denne guide bygger du et PlayerData-modul, der indlæser, holder i hukommelsen og gemmer hver spillers data via DataStoreService, og derefter gennemgår vi test, grænser og de måder, gemte data går tabt på.

Opdateret 20. november 202617 min. læsningSkrevet af

Kort fortalt

Brug DataStoreService fra et server-Script: indlæs spillerens data med GetAsync, når spilleren kommer ind, hold dem i en tabel, mens spilleren spiller, og gem med UpdateAsync på en timer, når spilleren går (PlayerRemoving), og når serveren lukker ned (game:BindToClose). Pak hvert kald ind i pcall, og prøv mislykkede kald igen et par gange.

  • For at teste i Studio skal du udgive dit place og slå File > Experience Settings > Security > Enable Studio Access to API Services til i et separat testspil: Studio bruger de samme data som de live servere.
  • Hvis en spillers data ikke blev indlæst, så gem aldrig den spiller. At gemme standardværdier overskriver spillerens rigtige fremskridt.
  • Gem én tabel pr. spiller under én nøgle, for eksempel User_12345, og gem på en timer, ikke ved hver ændring.
  • Til byttehandel eller betalte genstande tilføjer du session locking, så to servere ikke kan gemme den samme spiller.
På denne side
  1. Studio-adgang
  2. Sådan virker DataStore
  3. GetAsync og UpdateAsync
  4. 1. PlayerData-modul
  5. Sådan er modulet bygget
  6. 2. Arbejd med data
  7. 3. Advarsel
  8. 4. Test i Studio
  9. Hvorfor data går tabt
  10. Session locking
  11. Grænser
  12. Versioner og kopier
  13. Common errors
  14. With RoCode
  15. Ofte stillede spørgsmål
  16. Kilder og videre læsning

Før du starter: slå Studio-adgang til i en testkopi

Et spil, der kører i Studio, kan ikke tilgå datalagre, før du tillader det. Tilladelsen har en fælde, som Robloxs dokumentation advarer om: Studio læser og skriver så de samme datalagre som det live spil, så en test, der nulstiller dine mønter i Studio, nulstiller dem også i det live spil, og en fejl i testkoden kan ødelægge rigtige spilleres nøgler.

  1. Lav en testkopi. Gem dit place som en fil, åbn kopien, vælg File > Publish to Roblox As, og klik på Create new game. Tilføj den ikke som et place inde i det live spil: alle places i ét spil deler de samme datalagre.
  2. I testkopien åbner du File > Experience Settings og går til Security.
  3. Slå Enable Studio Access to API Services til, og klik på Save.

Kald til datalagre virker kun i server-Scripts; et LocalScript, der prøver, får en fejl, så klienter kan ikke skrive gemte data. Når en knap skal ændre dem, beder klienten serveren via en RemoteEvent, og serveren afgør det (se guiden til RemoteEvents, på engelsk).

Sådan gemmer datalagre spillernes data

IllustrationTesten fra guidens trin 4 i højt tempo: Play, Stop gemmer sessionen i datalageret, endnu et Play indlæser den, så Output viser 200.

Et datalager (data store) er et navngivet sæt nøgler og værdier på Robloxs servere, fælles for alle servere og alle places i dit spil. DataStoreService:GetDataStore("PlayerData") returnerer ét sådant datalager.

Robloxs anbefalinger koger ned til reglen ét datalager til spillerdata, én nøgle pr. spiller, én tabel i hver nøgle. Byg nøglen ud fra spillerens UserId, for eksempel User_12345, og aldrig ud fra et navn, spilleren kan ændre. Et fast mønster User_{UserId} lader også Robloxs automatiske behandling af retten til at blive glemt finde spillerens data, hvis du sætter den op.

Hvad du kan gemme i et datalager
TypeGemmes?Noter
Tal, strenge, booleske værdier, buffereJaStrenge skal være gyldig UTF-8. Gem ikke inf eller nan.
TabellerJaHvis alt indeni også kan gemmes. En tabel, hvis talnøgler ikke starter ved 1 (så dens længde er 0), kommer tilbage med de nøgler som strenge.
Instance, Vector3, CFrame, Color3NejAt gemme giver en fejl eller skriver nil. Gem genstandens navn eller positionen som tre tal.

Hver forespørgsel er et webkald, der kan fejle, tager tid og bruger af et budget pr. minut. Derfor læser pålidelige gemmesystemer data én gang, når spilleren kommer ind, holder dem i en servertabel, mens spilleren spiller, og skriver dem tilbage en gang imellem.

GetAsync, SetAsync eller UpdateAsync: hvad skal du vælge

Datalagerets vigtigste metoder
MetodeHvad den gørTil hvad
GetAsync(key)Læser en værdi. Resultatet caches på denne server i 4 sekunder.Indlæsning af spillerdata
SetAsync(key, value)Overskriver en værdi uden at læse den. Én skrivning.En ny nøgle eller en værdi, der ikke afhænger af den gamle
UpdateAsync(key, callback)Læser den nyeste værdi, giver den til din funktion og skriver det, funktionen returnerer. Én læsning og én skrivning.Gemning af spillerdata og enhver nøgle, som flere servere kan skrive
IncrementAsync(key, delta)Lægger et heltal til et gemt heltal.Tællere
RemoveAsync(key)Sletter en nøgle og returnerer den gamle værdi. Tidligere versioner kan stadig listes og læses.Sletning af spillerdata

SetAsync skriver i blinde: hvis to servere gemmer den samme nøgle næsten samtidig, vinder den sidste skrivning, uanset hvad den indeholder. UpdateAsync læser først den nuværende værdi, og hvis en anden server skriver imens, kører Roblox din funktion igen med den nye værdi. Roblox anbefaler den, når en skrivning afhænger af den nuværende værdi, eller flere servere kan skrive nøglen, og det er netop tilfældet med spillerdata. Funktionen har tre regler:

  • Den må ikke yielde: ingen task.wait() og ingen andre kald til datalagre indeni.
  • Den kan køre mere end én gang, så den må kun beregne den nye værdi og aldrig give genstande eller udløse events.
  • At returnere nil annullerer skrivningen. Modulet bruger det til ikke at overskrive data, der er gemt af en nyere version af spillet.

Trin 1: opret PlayerData-modulet

Dette ModuleScript er den eneste kode, der taler med datalageret. Det indlæser spillerens data ved indgang, holder dem i hukommelsen, gemmer hvert 180. sekund, når spilleren går, og når serveren lukker ned, og nægter at gemme dem, hvis data ikke blev indlæst.

  1. I Explorer holder du musen over ServerScriptService, klikker på + og indsætter et ModuleScript. Omdøb det til PlayerData, og erstat indholdet med koden nedenfor.
  2. Et ModuleScript kører kun, når et script henter det med require. Indsæt et Script med navnet Main i ServerScriptService med denne linje: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Andre server-scripts henter det på samme måde.
  3. Ændr DEFAULTS og typen Data, så de passer til dit spil, og lad hvert felt være et tal, en streng, en boolesk værdi eller en tabel.
Explorer efter trin 1-3
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript i ServerScriptService med navnet PlayerData
-- PlayerData: indlæser spillerens data ved indgang, holder dem i hukommelsen
-- og gemmer på en timer, når spilleren går, og når serveren lukker ned.
-- Andre server-scripts læser og ændrer 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 -- hæv, når dataenes form ændres, og tilføj et trin i migrate()
local AUTOSAVE_SECONDS = 180
-- I Studio giver et mislykket kald op med det samme, så en test uden adgang til datalageret er hurtig
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- fordobles efter hver fejl: 1, 2, 4

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

-- Hvad 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 indlæsningen fejlede: standarddata må ikke erstatte rigtigt fremskridt
}

-- Kaldes inde i hvert pcall nedenfor, så et place, der endnu ikke er udgivet
-- (uden adgang til datalageret), stadig indlæser spillere med standarddata
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- gemninger, der stadig er i gang, efter nøgle
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- Udløses med spilleren, når spillerens data er klar. Hent tabellen med PlayerData.Get(player):
-- en tabel, der sendes via en BindableEvent, kommer frem som en kopi, og at ændre den ændrer 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 frisk kopi, så spillere aldrig deler én Inventory-tabel
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- Bringer gemte data op til det nuværende skema. Returnerer nil, hvis de ikke kan bruges sikkert.
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 -- gemt af en nyere version af spillet: indlæs og overskriv ikke her
	end

	-- Ét trin pr. skemaændring, fra gammel til ny
	if version < 2 then
		-- Eksempel: i version 1 hed valutaen Gold. Kopiér den kun, hvis Coins mangler,
		-- så gamle data, hvor Coins allerede findes, men SchemaVersion mangler, beholder værdien.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Tilføj felter, der er kommet til siden spillerens seneste gemning, og erstat værdier af forkert 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

-- Kører et kald til datalageret i pcall. Ved fejl venter den og prøver igen, hver gang med fordoblet
-- ventetid og lidt tilfældighed, så serverne ikke prøver igen alle på én gang.
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 -- at returnere nil annullerer skrivningen
			end
			-- Skriv hele den nuværende tabel mærket 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()
		-- Start på et tilfældigt tidspunkt i intervallet, så serverne ikke gemmer alle på én gang
		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 lige har forladt denne server og er kommet tilbage, så lad først den seneste gemning blive færdig
	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 -- gik under indlæsningen: intet er ændret, intet at gemme
	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) -- en GUI kan læse det 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 autogem-løkken, og et nyt kald gør ingenting
	save(session)
end

-- Spillerens levende datatabel eller nil, indtil den er indlæst. Ændr den kun fra server-scripts.
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 indlæst og vil blive gemt. Tjek før ethvert salg.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Gemmer nu uden at vente på timeren, til vigtige øjeblikke som et køb.
-- Yielder og returnerer true, når gemningen lykkedes.
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, der kom ind før modulet første gang blev hentet
end

game:BindToClose(function()
	-- Serveren giver disse funktioner 30 sekunder, så vi gemmer alle samtidig
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Vent derefter på alle gemninger, der stadig er i gang, også dem, der blev startet i PlayerRemoving
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

Når spillet er udgivet, så ændr ikke STORE_NAME og nøglemønstret User_. At ændre en af dem peger modulet mod tomme nøgler, og hver spiller starter forfra med standardværdier.

Sådan passer modulet på data

Standardværdier og skemaversion

En ny spiller får en frisk kopi af DEFAULTS. Det skal være en kopi: hvis alle spillere delte én Inventory-tabel, ville en genstand, der blev tilføjet til én, dukke op hos alle.

Hver gemt tabel har en SchemaVersion. At tilføje et felt kræver ikke en ny version, fordi migrate udfylder manglende felter fra standardværdierne. At omdøbe eller omstrukturere kræver det: hæv SCHEMA_VERSION, og tilføj et trin, som i eksemplet, der omdøber Gold til Coins (i et nyt spil sletter du det og starter med 1). Data med en højere version end serverens kommer fra en nyere udgivelse, der stadig rulles ud, så gamle servere rører dem ikke.

En mislykket indlæsning gemmes aldrig

Denne regel beskytter mod fuld sletning. Hvis alle forsøg på indlæsning fejlede, spiller spilleren på standarddata, men canSave er false, så de værdier overskriver aldrig spillerens rigtige fremskridt. Modulet sætter også attributten DataLoaded til false, og trin 3 bruger den til at give spilleren besked. Robloxs referenceeksempel håndterer mislykkede indlæsninger på samme måde og foreslår det i stedet for et kick; hvis du hellere vil kicke, så kald player:Kick() med en besked der, hvor modulet skriver advarslen.

Nye forsøg med stigende pause

withRetries pakker hvert kald ind i pcall. Efter en fejl venter den 1, derefter 2, derefter 4 sekunder, hver gang plus tilfældigt op til halvdelen af den tid, og stopper efter fire forsøg (i Studio efter ét, så et place uden adgang til datalageret starter med det samme). Tilfældigheden spreder nye forsøg fra mange servere efter et nedbrud, og grænsen holder ventetiden inden for cirka 10 sekunder, inden for de 30 sekunder, serveren får til at lukke ned. Da hver gemning skriver hele den levende tabel via UpdateAsync, kan et nyt forsøg, der bliver færdigt for sent, ikke bringe gamle data tilbage.

Hvornår modulet gemmer

HvornårHvorfor
Hvert 180. sekund, mens spilleren er på serverenBegrænser tab ved et nedbrud. Den første gemning sker på et tilfældigt tidspunkt i intervallet, så serverne ikke gemmer alle på én gang. Robloxs referenceeksempel bruger også 180 sekunder.
Når spilleren går (PlayerRemoving)Den normale sidste gemning. Sessionen fjernes først, så autogem stopper.
Når serveren lukker ned (game:BindToClose)Alle, der stadig er på serveren, gemmes på én gang, og funktionen venter på hver gemning, der er i gang. Roblox giver den 30 sekunder.
Efter behov, via PlayerData.SaveNow(player)Efter noget, der ikke må gå tabt, for eksempel et køb.

Hvis en spiller kommer ind på den samme server igen, mens spillerens sidste gemning stadig er i gang, venter den nye indlæsning, til den gemning er færdig, så den ikke kan læse den gamle værdi.

Trin 2: læs og ændr data fra andre scripts

Alle server-scripts, der henter modulet, arbejder med de samme tabeller:

KaldHvad det gør
PlayerData.Get(player)Spillerens levende datatabel eller nil, indtil den er indlæst. Ændr felterne direkte, for eksempel data.Coins += 10, så tager næste gemning det med.
PlayerData.LoadedUdløses med spilleren, når spillerens data er klar, også efter en mislykket indlæsning. Sender kun spilleren, fordi en tabel, der sendes via en BindableEvent, kommer frem som en kopi.
PlayerData.CanSave(player)false, hvis indlæsningen fejlede. Tjek før ethvert salg: et køb, der ikke kan gemmes, forsvinder, når spilleren går.
PlayerData.SaveNow(player)Gemmer med det samme og returnerer true, hvis det lykkedes. Yielder.

Modulet er det eneste sted, hvor gemte data bor, og leaderstats er kun en visning: byg det som i guiden til leaderboards, udfyld det fra PlayerData.Get(player) i Loaded-handleren, og opdater begge, når en værdi ændres. Læs aldrig gemte værdier tilbage fra leaderstats, og lad aldrig et andet script gemme den samme nøgle.

Et script, der henter modulet, efter at spillerne er kommet ind, går glip af Loaded for dem. Forbind handleren, og gå derefter også Players:GetPlayers() igennem i en løkke, og håndtér alle, for hvem PlayerData.Get(player) allerede returnerer en tabel.

Erstatter du et gammelt gemme-script, for eksempel fra guiden til leaderboards? Dets værdier bliver i dets eget datalager og nøgle, så dette modul starter alle med standardværdier. Før lanceringen skal du enten pege STORE_NAME og præfikset User_ mod de gamle (migrate regner data uden SchemaVersion som version 1 og udfylder manglende felter) eller flytte de gamle værdier over og derefter slette det gamle script.

Klienter ændrer aldrig disse data direkte. En butiksknap udløser en RemoteEvent; serveren tjekker CanSave, sammenligner prisen med spillerens Coins, ændrer tabellen og kalder SaveNow. Guiden til butiks-GUI bygger sådan et køb på serversiden.

Et færdigt eksempel på at tilføje felter findes i guiden til klikker-simulatorer: den tilføjer PowerLevel og Rebirths til DEFAULTS og typen Data og ændrer dem derefter i den tabel, PlayerData.Get returnerer. migrate giver de nye felter til spillere med gamle gemninger.

Trin 3: fortæl spilleren, at spillerens data ikke blev indlæst

En spiller, hvis data ikke blev indlæst, skal vide, at denne session ikke bliver gemt, så spilleren kan komme ind igen i stedet for at spille forgæves. Dette LocalScript holder øje med 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 sætter DataLoaded én gang, efter forsøget på at indlæse denne spillers data
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

Trin 4: test gemning i Studio

Gør det i testkopien med Studio-adgang slået til.

  1. Giv dig selv noget at gemme. Under require-linjen i Main tilføjer du: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Tryk på Play. Output-vinduet (i menuen Window eller på fanen Script) viser dit navn og 100 (første gang), uden advarslen Could not load.
  3. Tryk på Stop. At afslutte testen lukker serveren, og modulet gemmer dig, før den lukker.
  4. Tryk på Play igen. Output skal vise 200, 100 mere end sidst. Hvis den viser det samme tal igen, lykkedes gemningen ikke: læs advarslerne over den.
  5. Test fejlvejen. Slå Studio-adgangen fra, og tryk på Play. Efter nogle sekunders nye forsøg viser Output Could not load User_... og 100, og banneret fra trin 3 dukker op. Stop testen, slå adgangen til igen, og tryk på Play: Output viser 300, dine gemte 200 plus 100, fordi den mislykkede session aldrig overskrev dine data.
  6. Slet testlinjen fra Main.

Hvorfor spillerdata går tabt

Her er de almindelige måder, et gemmesystem mister fremskridt på. Modulet lukker de første fire rækker og rækken om skemaet i koden; resten afhænger af, hvad og hvordan du gemmer, og den sidste kræver session locking.

Hvad der skerResultatSådan forhindrer du det
Indlæsningen fejlede, og scriptet gemmer alligevelStandardværdier overskriver rigtigt fremskridt: fuld sletningGem aldrig en spiller, hvis indlæsning fejlede
Gemning kun i PlayerRemovingEt nedbrud eller en nedlukning af serveren springer gemningen overAutogem plus BindToClose, der venter på sine gemninger
Ingen pcall eller intet nyt forsøgÉn mislykket forespørgsel stopper scriptet eller mister en gemningpcall med nogle nye forsøg spredt i tid
Gemning ved hver ændringForespørgsler sættes i kø; når der er 30 i køen, kasseres nyeHold data i hukommelsen, og gem på en timer
Gemning af noget, datalageret ikke kan gemmeGemningen giver en fejl, eller værdien kommer tilbage som nilGem tal, strenge, booleske værdier og tabeller af dem
Ændring af dataenes form uden migreringGamle gemninger indlæses i de forkerte felterSkemaversion og et migreringstrin
To scripts gemmer den samme nøgleHver gemning overskriver den andens felterÉt modul ejer nøglen
To servere holder den samme spillerServeren med de gamle data gemmer sidst og overskriver det nye fremskridtSession locking

Session locking, "lock lost" og ProfileStore

En spiller er forbundet til én server ad gangen, men den gamle servers sidste gemning kan stadig være i gang, når spilleren kommer ind på en ny: et langsomt nyt forsøg, en teleport eller en hurtig genindgang. Hvis den nye server indlæser data først, har den de gamle data, og den server, der gemmer sidst, vinder. Robloxs dokumentation nævner, at det hul i spil med byttehandel er en almindelig årsag til duplikering af genstande.

Session locking lukker det hul. Når en server indlæser en spillers nøgle, skriver den i det samme UpdateAsync-kald sit lås-ID i nøglens metadata. Enhver anden server, der finder en lås, som ikke er udløbet og ikke er sat af den selv, vil hverken indlæse eller gemme den nøgle. Ejeren fornyer låsen ved hver autogem og fjerner den ved den sidste gemning; hvis den holder op med at forny den, udløber låsen, og en anden server kan overtage den.

Hvad "lock lost" betyder

I et system med session locking har en server mistet låsen, når en anden server nu ejer spillerens nøgle, fordi låsen udløb eller blev overtaget. Dens kopi kan være forældet, så den skal holde op med at gemme den spiller; den almindelige reaktion er at kicke spilleren med en besked om at forbinde igen. Hvis du har set "lock lost" som spiller, er det en besked fra det spils eget gemmesystem, og kun dets udviklere kan forklare den.

Har du brug for det?

Modulet fra denne guide bruger ikke session locking. Uden låsning er det reelle værste tilfælde dette: i et sjældent kapløb mister en spiller det, den tjente på den gamle server efter dens seneste vellykkede gemning. Tilføj låsning, når duplikering eller tab koster spillerne noget reelt: byttehandel, developer products, sjældne genstande eller hyppige teleporter.

MulighedHvad det erHvad du skal vide
Modulet fra denne guideIndlæsning, cache i hukommelsen, nye forsøg, autogem, gemning ved nedlukning og skemaversioner, uden låsningKort nok til at læse helt igennem og ændre
Robloxs eksempel til spillerdata og købReferencekode fra Roblox med session locking, nye forsøg i rækkefølge for hver nøgle og håndtering af kvitteringer for købRoblox siger, at den ikke er afprøvet over tid i et populært spil og ikke bør bruges, som den er, uden omfattende test
ProfileStoreEt gratis open source-modul fra fællesskabet, efterfølger til ProfileService, bygget omkring session locking og autogemIkke fra Roblox. At flytte et eksisterende spil over på det kræver migrering af allerede gemte data

For ethvert tredjepartsmodul anbefaler Roblox at tjekke, hvem der ejer det, om det vedligeholdes, og hvordan du kommer til dine data uden det. Den samme dokumentation kalder DataStore2 et forældet bibliotek, som nye spil ikke bør bruge.

Grænser for datalagre

Det er grænserne fra Robloxs dokumentation pr. 30. september 2026. Roblox reviderer dem, så tjek siden med fejlkoder og grænser (på engelsk), før du regner med et præcist tal.

Standardgrænser for forespørgsler for hver server, pr. minut
Type forespørgselAlmindelige datalagreOrdnede datalagre
Læsning: GetAsync, læsning i UpdateAsync60 + 40 × spillere60 + 40 × spillere
Skrivning: SetAsync, IncrementAsync, skrivning i UpdateAsync60 + 40 × spillere30 + 5 × spillere
Liste: ListKeysAsync eller GetSortedAsync for ordnede datalagre5 + 2 × spillere5 + 2 × spillere
Sletning: RemoveAsync60 + 40 × spillere30 + 5 × spillere

Med 20 spillere kan en server lave 860 almindelige skrivninger i minuttet; dette moduls autogem bruger cirka 7 af dem plus én for hver spiller, der går. Budgettet opbruges af at gemme ved hver opsamlet mønt. Et andet budget gælder hele spillet og deles med Open Cloud: 300 læsninger i minuttet plus 40 for hver spiller online og 300 skrivninger plus 20 pr. spiller.

Grænser for størrelse og gennemstrømning
GrænseVærdi
Datalagerets navn, nøglens navn, scope50 tegn hver
Værdien i én nøgle4 194 304 tegn som JSON
Læsning af én nøgle fra alle servere25 MB i minuttet
Skrivning til én nøgle fra alle servere4 MB i minuttet, hver forespørgsel rundes op til næste KB
Ventende forespørgsler30 pr. kø; ud over det fejler forespørgsler med fejl 301-306
Lager for hele spillet500 MB plus 1 MB for hver bruger nogensinde

Mål størrelsen af en spillers data med #HttpService:JSONEncode(data), og se det resterende budget på en live server med DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite). GetAsync-kald, som 4-sekunders-cachen besvarede, tælles ikke. Run-tilstanden i Studio har sine egne, muligvis lavere grænser, så til test af forespørgselsgrænser anbefaler Roblox Team Create.

Versioner og sikkerhedskopier

Almindelige datalagre gemmer historik for dig. Den første skrivning til en nøgle i hver time i UTC gemmes som en version, og senere skrivninger i den time overskriver hinanden. En gammel version udløber 30 dage efter, at en nyere skrivning erstattede den; den seneste udløber aldrig. Ordnede datalagre gemmer ikke versioner.

For at rulle én spiller tilbage åbner du Data Stores Manager (Creations, dit spil, Configure > Data Stores Manager), vælger spillerens nøgle, vælger en tidligere version og klikker på Revert; det kræver Edit-rettighed. Gør det, mens spilleren ikke er online, ellers gemmer serveren med spillerens session sin kopi oven på tilbagerulningen. Fra et server-script finder og læser ListVersionsAsync og GetVersionAsync en gammel version, som du derefter skriver tilbage som den nuværende værdi.

Før du udgiver en opdatering, der ændrer måden, data gemmes på, anbefaler Roblox at tage et snapshot via Open Cloud Snapshot Data Stores API (ét om dagen pr. spil). Uden det overskriver en fejlagtig gemning kl. 3:30 UTC alt, hvad der blev skrevet til den nøgle siden 3:00, fordi den havner i den samme timeversion.

Almindelige fejl og løsninger

Fejl fra datalagre vises i Studios Output-vindue, og modulet skriver en advarsel med Robloxs fejltekst ved hvert mislykket forsøg. Guiden til script-fejl forklarer, hvordan man overhovedet læser Output.

StudioAccessToApisNotAllowed (fejl 403)

"Can't write to DataStore from Studio because API access is not enabled." Udgiv dit place, og slå derefter Enable Studio Access to API Services til under File > Experience Settings > Security, i testkopien.

DataStore request was added to queue

Serveren sender forespørgsler hurtigere, end budgettet tillader, eller skriver den samme nøgle for ofte, som regel fordi den gemmer ved hver ændring eller i en løkke. Når der er 30 forespørgsler i køen, fejler nye med fejl 301-306. Hold data i hukommelsen, og gem på en timer.

CantStoreValue (fejl 104), eller et felt kommer tilbage som nil

Tabellen indeholder noget, datalageret ikke kan gemme, for eksempel en Instance, en Vector3 eller en Color3. Gem i stedet et navn, et ID eller simple tal, og genskab objektet ved indlæsning.

ValueTooLarge (fejl 105)

Én nøgle indeholder mere end 4 194 304 tegn JSON. Mål med #HttpService:JSONEncode(data), fjern det, der kan genskabes, eller del data op i flere faste nøgler.

Ingen fejl, men data gemmes ikke

Led efter modulets advarsel Could not load: efter en mislykket indlæsning nægter det med vilje at gemme. Ellers blev værdien sandsynligvis ændret i et LocalScript, hvilket aldrig når serveren, eller et andet script gemmer den samme nøgle.

Data nulstilles ved hver genindgang

Nøglen ændrer sig mellem sessioner (bygget ud fra player.Name, eller du har ændret STORE_NAME), indlæsningen fejler, og du ser standardværdier, eller ingen henter modulet, så det kører slet ikke. Tjek Output, og at Main henter PlayerData.

Byg det med RoCode

Hvis du ikke har lyst til at bygge det her i hånden, kan RoCode gøre det direkte i det place, du har åbent. Det er en uafhængig AI-agent, ikke fra Roblox, der arbejder via et plugin til Roblox Studio: den skriver Luau, der bruger DataStoreService som ethvert script, og opretter scripts i din Explorer. Selv tilgår den aldrig dine datalagre, men med plugin 3.9 eller nyere kan den trykke på Play for en kort playtest, hvor dine scripts kører som i enhver test.

Du skriver

Tilføj gemning til mit spil: gem Coins, Level og Inventory i et PlayerData-modul med autogem og gemning ved nedlukning af serveren, og vis Coins i de leaderstats, jeg allerede har.

RoCode gør
  • Kan søge efter eksisterende leaderstats og DataStore-kode med Search Scripts og Read Script for at udvide det, du har, i stedet for at tilføje et ekstra gemme-script. I et stort place så nævn scriptet eller mappen i beskeden.
  • Opretter ModuleScriptet og det Script, der henter det, med Create Script eller ændrer eksisterende med Edit Script
  • Kører Check Script for hvert script, den skriver: et kompileringstjek inde i Studio med en kort liste over advarsler, ikke en typekontrol og ikke en testkørsel
  • Sender ændringerne i pakker, og hver pakke er et fortrydelsespunkt (undo) i Studio

Enable Studio Access to API Services i testkopien skal du stadig selv slå til: RoCode kan ikke ændre den indstilling. Med plugin 3.9 eller nyere læser dens korte playtest fejlene, og med plugin 3.9.11 eller nyere kan den styre en testfigur for at tjekke, at spillet virker, men den tjekker kun det, den selv har besluttet at tjekke, så spil selv, og forvis dig om, at Coins, Level og Inventory gemmes og indlæses. Hvis gemningen fejlede i din test, kan Check Output læse Server-linjerne fra den playtest, du kørte. Gemning tilføjes som regel, når den grundlæggende spilløkke allerede virker; at lave et Roblox-spil med AI ét system ad gangen viser den rækkefølge. Sådan forbinder RoCode til Studio.

Ofte stillede spørgsmål

Hvordan slår jeg DataStore til i Roblox Studio?

Udgiv dit place, åbn File > Experience Settings > Security, slå Enable Studio Access to API Services til, og klik på Save. Gør det i et separat testspil, fordi Studio så bruger de samme datalagre som det spils live servere.

Gemmer Roblox spillerdata automatisk?

Nej. Intet om en spiller gemmes efter sessionen, medmindre et server-script gemmer det via DataStoreService, og det gælder også leaderstats.

Hvad skal jeg vælge: ProfileStore eller DataStoreService direkte?

ProfileStore er også bygget på datalagre, så spørgsmålet er, om du vil have session locking skrevet og vedligeholdt for dig. Til byttehandel, betalte genstande eller hyppige teleporter er låsning det værd, fra et bibliotek eller Robloxs referenceeksempel. Til et mindre spil er et modul som dette nemmere at læse og ændre.

Hvordan nulstiller eller sletter jeg en spillers data?

I Data Stores Manager finder du nøglen og vælger Mark for Deletion, hvilket kan fortrydes inden for ventetiden, eller du kalder RemoveAsync for nøglen fra et server-script. Gør det, mens spilleren ikke er online, ellers skriver spillerens servers næste gemning data tilbage. I testkopien starter alle forfra, hvis du ændrer STORE_NAME; gør det aldrig i det live spil.

Kilder og videre læsning

Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.

Prøv RoCode i dit eget spil.

Gratis credits hver dag, intet kort. Installér pluginet, beskriv en funktion, og se hvad der dukker op i Studio.