Útmutató · Játékosadatok

Hogyan mentsd a játékosadatokat a Roblox Studióban DataStore-ral

A Roblox semmit sem jegyez meg a játékosról két munkamenet között, ha egy szerverscript nem mentette el. Ebben az útmutatóban összeraksz egy PlayerData modult, amely a DataStoreService segítségével betölti, a memóriában tartja és elmenti minden játékos adatait, aztán végigveszed a tesztelést, a korlátokat, és azt, hogyan vesznek el a mentett adatok.

Frissítve 2026. november 20.17 perc olvasásSzerző:

Röviden

Használd a DataStoreService-t egy szerveroldali Scriptből: töltsd be a játékos adatait GetAsync-kel, amikor belép, tartsd egy táblában, amíg játszik, és mentsd UpdateAsync-kel időzítve, kilépéskor (PlayerRemoving) és a szerver leállásakor (game:BindToClose). Minden hívást csomagolj pcall-ba, és a sikerteleneket próbáld újra néhányszor.

  • A Studióban való teszteléshez publikáld a place-t, és kapcsold be a File > Experience Settings > Security > Enable Studio Access to API Services beállítást egy külön tesztjátékban: a Studio ugyanazokat az adatokat használja, mint az élő szerverek.
  • Ha egy játékos adatai nem töltődtek be, soha ne mentsd azt a játékost. Az alapértékek mentése felülírja a valódi előrehaladását.
  • Játékosonként egy táblát tárolj egy kulcs alatt, például User_12345, és időzítve ments, ne minden változáskor.
  • Tárgycseréhez vagy fizetős tárgyakhoz adj hozzá munkamenet-zárolást, hogy két szerver ne menthesse ugyanazt a játékost.
Ezen az oldalon
  1. Studio hozzáférés
  2. Hogyan működik a DataStore
  3. GetAsync és UpdateAsync
  4. 1. PlayerData modul
  5. Hogyan épül fel a modul
  6. 2. Munka az adatokkal
  7. 3. Figyelmeztetés
  8. 4. Teszt a Studióban
  9. Miért vesznek el az adatok
  10. Munkamenet-zárolás
  11. Korlátok
  12. Verziók és mentések
  13. Common errors
  14. With RoCode
  15. Gyakori kérdések
  16. Források és további olvasnivaló

Mielőtt elkezded: kapcsold be a Studio hozzáférést egy tesztmásolatban

A Studióban futó játék nem fér hozzá az adattárakhoz, amíg ezt nem engedélyezed. Az engedélynek van egy csapdája, amelyre a Roblox dokumentációja figyelmeztet: a Studio ekkor ugyanazokat az adattárakat olvassa és írja, mint az élő játék, ezért egy teszt, amely a Studióban lenullázza az érméidet, az élő játékban is lenullázza őket, egy hiba a tesztkódban pedig elronthatja valódi játékosok kulcsait.

  1. Készíts tesztmásolatot. Mentsd a place-t fájlba, nyisd meg a másolatot, válaszd a File > Publish to Roblox As menüpontot, és kattints a Create new game gombra. Ne add hozzá place-ként az élő játékon belül: egy játék összes place-e ugyanazokon az adattárakon osztozik.
  2. A tesztmásolatban nyisd meg a File > Experience Settings ablakot, és lépj a Security részre.
  3. Kapcsold be az Enable Studio Access to API Services beállítást, és kattints a Save gombra.

Az adattár-hívások csak szerveroldali Script-ekben működnek; az a LocalScript, amely megpróbálja, hibát kap, így a kliensek nem írhatnak mentett adatokat. Ha egy gombnak módosítania kell őket, a kliens RemoteEventen keresztül kéri meg a szervert, és a szerver dönt (lásd a RemoteEvents útmutatót, angolul).

Hogyan tárolják az adattárak a játékosadatokat

IllusztrációAz útmutató 4. lépésének ellenőrzése gyorsítva: Play, a Stop elmenti a munkamenetet az adattárba, az újabb Play betölti, ezért az Output 200-at mutat.

Az adattár (data store) kulcs-érték párok elnevezett gyűjteménye a Roblox szerverein, amely közös a játékod összes szervere és összes place-e között. A DataStoreService:GetDataStore("PlayerData") egy ilyen tárat ad vissza.

A Roblox ajánlásai egy szabályra futnak ki: egy tár a játékosadatoknak, játékosonként egy kulcs, minden kulcsban egy tábla. A kulcsot a játékos UserId-jéből állítsd össze, például User_12345, és soha ne a nevéből, amelyet megváltoztathat. Az állandó User_{UserId} minta azt is lehetővé teszi, hogy a Roblox automatikus, az elfeledtetéshez való jogot kezelő folyamata megtalálja a játékos adatait, ha beállítod.

Mit lehet egy adattárba menteni
TípusMenthető?Megjegyzések
Számok, stringek, logikai értékek, bufferekIgenA stringeknek érvényes UTF-8-nak kell lenniük. Ne tárolj inf vagy nan értéket.
TáblákIgenHa minden, ami bennük van, szintén menthető. Az a tábla, amelynek numerikus kulcsai nem 1-gyel kezdődnek (ezért a hossza 0), ezekkel a kulcsokkal stringként tér vissza.
Instance, Vector3, CFrame, Color3NemA mentés hibát ad vagy nil-t ír. Mentsd a tárgy nevét, vagy a pozíciót három számként.

Minden kérés egy webes hívás, amely meghiúsulhat, időbe telik, és a percenkénti keretből fogy. Ezért a megbízható mentőrendszerek egyszer olvassák be az adatokat, amikor a játékos belép, egy szerveroldali táblában tartják őket, amíg játszik, és időnként visszaírják.

GetAsync, SetAsync vagy UpdateAsync: melyiket válaszd

Az adattár fő metódusai
MetódusMit csinálMire való
GetAsync(key)Kiolvassa az értéket. Az eredményt ez a szerver 4 másodpercig gyorsítótárazza.A játékosadatok betöltése
SetAsync(key, value)Felülírja az értéket anélkül, hogy kiolvasná. Egy írás.Új kulcs, vagy olyan érték, amely nem függ a régitől
UpdateAsync(key, callback)Kiolvassa a legutóbbi értéket, átadja a függvényednek, és azt írja vissza, amit a függvény visszaad. Egy olvasás és egy írás.A játékosadatok mentése, és minden kulcs, amelyet több szerver is írhat
IncrementAsync(key, delta)Egy egész számot ad hozzá egy mentett egész számhoz.Számlálók
RemoveAsync(key)Törli a kulcsot, és visszaadja a régi értéket. A korábbi verziók továbbra is listázhatók és olvashatók.Játékosadatok törlése

A SetAsync vakon ír: ha két szerver majdnem egyszerre menti ugyanazt a kulcsot, az utolsó írás nyer, bármi is van benne. Az UpdateAsync előbb kiolvassa az aktuális értéket, és ha közben egy másik szerver ír, a Roblox újra lefuttatja a függvényedet az új értékkel. A Roblox mindig ezt ajánlja, ha az írás az aktuális értéktől függ, vagy ha a kulcsot több szerver is írhatja, és a játékosadatok pontosan ilyenek. A függvényre három szabály vonatkozik:

  • Nem adhatja át a végrehajtást (yield): semmi task.wait() és semmilyen más adattár-hívás benne.
  • Többször is lefuthat, ezért csak az új értéket számolhatja ki, és soha nem adhat ki tárgyakat, és nem indíthat eseményeket.
  • A nil visszaadása megszakítja az írást. A modul ezt használja, hogy ne írja felül a játék egy újabb verziója által mentett adatokat.

1. lépés: hozd létre a PlayerData modult

Ez a ModuleScript az egyetlen kód, amely az adattárral kommunikál. Belépéskor betölti a játékos adatait, a memóriában tartja őket, 180 másodpercenként, kilépéskor és a szerver leállásakor ment, és nem hajlandó menteni azokat, akiknek az adatai nem töltődtek be.

  1. Az Explorerben vidd az egeret a ServerScriptService fölé, kattints a + gombra, és szúrj be egy ModuleScript-et. Nevezd át PlayerData-ra, és cseréld le a tartalmát az alábbi kódra.
  2. A ModuleScript csak akkor fut le, amikor egy másik script betölti (require). Szúrj be a ServerScriptService-be egy Main nevű Script-et ezzel a sorral: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). A többi szerverscript ugyanígy tölti be.
  3. Igazítsd a DEFAULTS táblát és a Data típust a játékodhoz úgy, hogy minden mező szám, string, logikai érték vagy tábla maradjon.
Az Explorer az 1-3. lépés után
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript helye: ServerScriptService neve: PlayerData
-- PlayerData: belépéskor betölti a játékos adatait, a memóriában tartja őket,
-- és időzítve, kilépéskor és a szerver leállásakor elmenti.
-- A többi szerverscript a PlayerData.Get(player) segítségével olvassa és módosítja őket.

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

local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- emeld, amikor az adatok formája változik, és adj hozzá egy lépést a migrate()-hez
local AUTOSAVE_SECONDS = 180
-- A Studióban a sikertelen hívás azonnal feladja, így a tárhozzáférés nélküli teszt gyors
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- minden hiba után duplázódik: 1, 2, 4

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

-- Ezzel kezd egy teljesen új játékos
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- false, ha a betöltés nem sikerült: az alapadatok nem írhatják felül a valódi előrehaladást
}

-- Minden alábbi pcall-on belül hívódik, így egy még nem publikált place
-- (tárhozzáférés nélkül) is betölti a játékosokat alapadatokkal
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- a még folyamatban lévő mentések, kulcsonként
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- A játékossal sül el, amikor az adatai készen állnak. A táblát a PlayerData.Get(player)-rel kérd le:
-- a BindableEventen át küldött tábla másolatként érkezik, és a módosítása semmit sem változtat.
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) -- friss másolat, hogy a játékosok soha ne osztozzanak egy Inventory táblán
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- A mentett adatokat az aktuális sémára hozza. nil-t ad vissza, ha nem használhatók biztonságosan.
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 -- a játék egy újabb verziója mentette: itt ne töltsd be és ne írd felül
	end

	-- Sémaváltozásonként egy lépés, a régiektől az újak felé
	if version < 2 then
		-- Példa: az 1-es verzióban a pénznem neve Gold volt. Csak akkor másoljuk át, ha nincs Coins,
		-- hogy azok a régi adatok, amelyekben már van Coins, de nincs SchemaVersion, megtartsák az értéküket.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Hozzáadjuk a játékos utolsó mentése óta megjelent mezőket, és lecseréljük a rossz típusú értékeket
	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

-- pcall-ban futtat egy adattár-hívást. Hiba esetén vár és újra próbálja, a várakozást minden alkalommal
-- megduplázza, és egy kis véletlent ad hozzá, hogy a szerverek ne egyszerre próbálkozzanak újra.
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 -- a nil visszaadása megszakítja az írást
			end
			-- A teljes aktuális táblát írjuk, a játékos UserId-jével megjelölve
			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()
		-- Az intervallum egy véletlen pontján kezdünk, hogy a szerverek ne egyszerre mentsenek
		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

	-- Ha a játékos épp most lépett ki erről a szerverről és visszajött, előbb hagyjuk befejeződni az utolsó mentést
	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 -- betöltés közben kilépett: semmi sem változott, nincs mit menteni
	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) -- a GUI kiolvashatja ezt, és figyelmeztetheti a játékost
	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 -- leállítja az automentés ciklusát, és egy újabb hívás nem csinál semmit
	save(session)
end

-- A játékos élő adattáblája, vagy nil, amíg be nem töltődött. Csak szerverscriptekből módosítsd.
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True, ha a játékos adatai betöltődtek és menteni fogjuk őket. Minden eladás előtt ellenőrizd.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Most ment, az időzítőt meg nem várva, fontos pillanatokban, például vásárláskor.
-- Átadja a végrehajtást, és true-t ad vissza, ha a mentés sikerült.
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) -- azok a játékosok, akik a modul első betöltése előtt léptek be
end

game:BindToClose(function()
	-- A szerver 30 másodpercet ad ezeknek a függvényeknek, ezért mindenkit egyszerre mentünk
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Aztán megvárjuk az összes még futó mentést, a PlayerRemovingban indítottakat is
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

Ha a játék már megjelent, ne változtasd meg a STORE_NAME értékét és a User_ kulcsmintát. Bármelyik megváltoztatása üres kulcsokra irányítja a modult, és minden játékos elölről kezd az alapértékekkel.

Hogyan vigyáz a modul az adatokra

Alapértékek és sémaverzió

Az új játékos a DEFAULTS egy friss másolatát kapja. Ennek tényleg másolatnak kell lennie: ha minden játékos egy Inventory táblán osztozna, az egyiküknek adott tárgy mindenkinél megjelenne.

Minden mentett tábla tartalmaz egy SchemaVersion mezőt. Egy mező hozzáadásához nem kell új verzió, mert a migrate az alapértékekből tölti ki a hiányzó mezőket. Átnevezéshez vagy átszervezéshez kell: emeld a SCHEMA_VERSION értékét, és adj hozzá egy lépést, mint a példában, amely a Gold mezőt Coins-ra nevezi át (egy új játékban töröld, és kezdj 1-ről). A szerverénél magasabb verziójú adatok egy újabb kiadástól származnak, amely még élesedik, ezért a régi szerverek nem nyúlnak hozzájuk.

A sikertelen betöltést soha nem mentjük

Ez a szabály véd a teljes törléstől. Ha minden betöltési kísérlet meghiúsult, a játékos alapadatokon játszik, de a canSave értéke false, így ezek az értékek soha nem írják felül a valódi előrehaladását. A modul a DataLoaded attribútumot is false-ra állítja, és a 3. lépés ezt használja, hogy szóljon a játékosnak. A Roblox referenciapéldája ugyanígy kezeli a sikertelen betöltéseket, és ezt javasolja a kirúgás helyett; ha inkább kirúgnád, hívd meg a player:Kick()-et egy üzenettel ott, ahol a modul a figyelmeztetést kiírja.

Újrapróbálás növekvő szünettel

A withRetries minden hívást pcall-ba csomagol. Hiba után 1, aztán 2, aztán 4 másodpercet vár, minden alkalommal plusz véletlenszerűen legfeljebb ennek az időnek a felét, és négy kísérlet után megáll (a Studióban egy után, hogy a tárhozzáférés nélküli place azonnal elinduljon). A véletlen széthúzza sok szerver újrapróbálásait egy kiesés után, a korlát pedig nagyjából 10 másodpercen belül tartja a várakozást, azon a 30 másodpercen belül, amelyet a szerver a leállásra kap. Mivel minden mentés a teljes élő táblát írja UpdateAsync-kel, egy késve befejeződő újrapróbálás nem hozhat vissza régi adatokat.

Mikor ment a modul

MikorMiért
180 másodpercenként, amíg a játékos a szerveren vanKorlátozza a veszteséget egy összeomláskor. Az első mentés az intervallum egy véletlen pontjára esik, hogy a szerverek ne egyszerre mentsenek. A Roblox referenciapéldája is 180 másodpercet használ.
Amikor a játékos kilép (PlayerRemoving)A szokásos végső mentés. Előbb a munkamenet törlődik, így az automentés leáll.
Amikor a szerver leáll (game:BindToClose)Mindenki, aki még a szerveren van, egyszerre mentődik, és a függvény minden folyamatban lévő mentést megvár. A Roblox 30 másodpercet ad neki.
Kérésre, a PlayerData.SaveNow(player) segítségévelValami után, amit nem szabad elveszíteni, például vásárlás után.

Ha a játékos újra belép ugyanarra a szerverre, miközben a végső mentése még folyamatban van, az új betöltés megvárja ennek a mentésnek a végét, így nem olvashat régi értéket.

2. lépés: olvasd és módosítsd az adatokat más scriptekből

Minden szerverscript, amely betölti a modult, ugyanazokkal a táblákkal dolgozik:

HívásMit csinál
PlayerData.Get(player)A játékos élő adattáblája, vagy nil, amíg be nem töltődött. A mezőket közvetlenül módosítsd, például data.Coins += 10, és a következő mentés ezt átveszi.
PlayerData.LoadedA játékossal sül el, amikor az adatai készen állnak, sikertelen betöltés után is. Csak a játékost adja át, mert a BindableEventen át küldött tábla másolatként érkezik.
PlayerData.CanSave(player)false, ha a betöltés nem sikerült. Minden eladás előtt ellenőrizd: az a vásárlás, amelyet nem lehet menteni, elvész, amikor a játékos kilép.
PlayerData.SaveNow(player)Azonnal ment, és true-t ad vissza, ha sikerült. Átadja a végrehajtást.

A modul az egyetlen hely, ahol a mentett adatok élnek, a leaderstats csak megjelenítés: rakd össze úgy, mint a ranglista útmutatóban, töltsd fel a PlayerData.Get(player) adataival a Loaded kezelőjében, és egy érték változásakor frissítsd mindkettőt. Soha ne olvasd vissza a mentett értékeket a leaderstatsból, és soha ne engedd, hogy egy második script ugyanazt a kulcsot mentse.

Az a script, amely azután tölti be a modult, hogy a játékosok beléptek, lemarad a Loaded eseményükről. Kösd be a kezelőt, aztán menj végig egy ciklussal a Players:GetPlayers() listán is, és kezeld le mindazokat, akiknél a PlayerData.Get(player) már táblát ad vissza.

Egy régi mentőscriptet cserélsz le, például a ranglista útmutatóból valót? Annak értékei a saját tárában és kulcsában maradnak, ezért ez a modul mindenkit az alapértékekkel indít. Indulás előtt vagy irányítsd a STORE_NAME értékét és a User_ előtagot a régiekre (a migrate az SchemaVersion nélküli adatokat 1-es verziónak tekinti, és kitölti a hiányzó mezőket), vagy vidd át a régi értékeket, aztán töröld a régi scriptet.

A kliensek soha nem módosítják közvetlenül ezeket az adatokat. A bolt gombja egy RemoteEventet indít; a szerver ellenőrzi a CanSave-et, összeveti az árat a játékos Coins értékével, módosítja a táblát, és meghívja a SaveNow-t. A bolt GUI útmutató egy ilyen szerveroldali vásárlást épít fel.

Kész példát a mezők hozzáadására a clicker szimulátor útmutatóban találsz: hozzáadja a PowerLevel és a Rebirths mezőt a DEFAULTS táblához és a Data típushoz, aztán módosítja őket abban a táblában, amelyet a PlayerData.Get visszaad. A migrate a régi mentésű játékosoknak is megadja az új mezőket.

3. lépés: szólj a játékosnak, hogy az adatai nem töltődtek be

Annak a játékosnak, akinek az adatai nem töltődtek be, tudnia kell, hogy ez a munkamenet nem mentődik, hogy újra belépjen, és ne játsszon hiába. Ez a LocalScript figyeli a DataLoaded attribútumot, és sávot jelenít meg, ha az értéke false.

LocalScript helye: StarterPlayerScripts neve: 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

-- A szerver egyszer állítja be a DataLoaded értékét, miután megpróbálta betölteni ennek a játékosnak az adatait
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

4. lépés: teszteld a mentést a Studióban

Ezt a bekapcsolt Studio hozzáférésű tesztmásolatban csináld.

  1. Adj magadnak valamit, amit menteni lehet. A Main require sora alá írd be: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Kattints a Play gombra. Az Output ablak (a Window menüben vagy a Script fülön) a nevedet és 100-at mutat (első futtatáskor), Could not load figyelmeztetés nélkül.
  3. Kattints a Stop gombra. A teszt befejezése bezárja a szervert, és a modul bezárás előtt elment téged.
  4. Kattints újra a Play gombra. Az Outputnak 200-at kell mutatnia, 100-zal többet, mint legutóbb. Ha megint ugyanazt a számot mutatja, a mentés nem sikerült: olvasd el a fölötte lévő figyelmeztetéseket.
  5. Teszteld a hibás utat. Kapcsold ki a Studio hozzáférést, és kattints a Play gombra. Néhány másodpercnyi újrapróbálás után az Output a Could not load User_... szöveget és 100-at mutat, és megjelenik a 3. lépés sávja. Állítsd le a tesztet, kapcsold vissza a hozzáférést, és kattints a Play gombra: az Output 300-at mutat, a mentett 200-at plusz 100-at, mert a sikertelen munkamenet soha nem írta felül az adataidat.
  6. Töröld a tesztsort a Main scriptből.

Miért vesznek el a játékosadatok

Ezek a szokásos módok, ahogy egy mentőrendszer elveszíti az előrehaladást. A modul a kódban lezárja az első négy sort és a sémáról szóló sort; a többi attól függ, mit és hogyan tárolsz, az utolsóhoz pedig munkamenet-zárolás kell.

Mi történikEredményHogyan előzd meg
A betöltés nem sikerült, a script mégis mentAz alapértékek felülírják a valódi előrehaladást: teljes törlésSoha ne mentsd azt a játékost, akinek a betöltése nem sikerült
Mentés csak a PlayerRemoving-banEgy összeomlás vagy a szerver leállása kihagyja a mentéstAutomentés, plusz BindToClose, amely megvárja a saját mentéseit
Nincs pcall vagy nincs újrapróbálásEgyetlen sikertelen kérés leállítja a scriptet, vagy elveszít egy mentéstpcall néhány időben széthúzott újrapróbálással
Mentés minden változáskorA kérések sorba állnak; ha 30 van a sorban, az újakat eldobjaTartsd az adatokat a memóriában, és időzítve ments
Olyasmi mentése, amit a tár nem tud tárolniA mentés hibát ad, vagy az érték nil-ként tér visszaSzámokat, stringeket, logikai értékeket és ezekből álló táblákat ments
Az adatok formájának megváltoztatása migráció nélkülA régi mentések rossz mezőkbe töltődnekSémaverzió és migrációs lépés
Két script menti ugyanazt a kulcsotMindegyik mentés felülírja a másik mezőitA kulcs egyetlen modulé
Két szerver tartja ugyanazt a játékostA régi adatokkal rendelkező szerver ment utoljára, és felülírja az új előrehaladástMunkamenet-zárolás

Munkamenet-zárolás, „lock lost” és ProfileStore

A játékos egyszerre egy szerverhez kapcsolódik, de a régi szerver végső mentése még folyamatban lehet, amikor belép egy újra: lassú újrapróbálás, teleport vagy gyors újracsatlakozás. Ha az új szerver tölti be először az adatokat, régi adatai lesznek, és az a szerver nyer, amelyik utoljára ment. A Roblox dokumentációja megjegyzi, hogy a cserét tartalmazó játékokban ez a rés gyakori oka a tárgyak megduplázódásának.

A munkamenet-zárolás lezárja ezt a rést. Amikor egy szerver betölti egy játékos kulcsát, ugyanabban az UpdateAsync hívásban beírja a zárolási azonosítóját a kulcs metaadataiba. Minden más szerver, amely olyan le nem járt zárat talál, amelyet nem ő tett rá, nem tölti be és nem menti ezt a kulcsot. A tulajdonos minden automentéskor megújítja a zárat, és a végső mentéskor feloldja; ha abbahagyja a megújítást, a zár lejár, és egy másik szerver átveheti.

Mit jelent a „lock lost”

Egy munkamenet-zárolást használó rendszerben a szerver elvesztette a zárat, ha a játékos kulcsa most egy másik szerveré, mert a zár lejárt vagy átvették. A másolata elavult lehet, ezért abba kell hagynia ennek a játékosnak a mentését; a szokásos reakció: kirúgni egy üzenettel, hogy csatlakozzon újra. Ha játékosként láttad a „lock lost” üzenetet, az az adott játék saját mentőrendszerének üzenete, és csak a játék fejlesztői tudják megmagyarázni.

Szükséged van rá?

Az útmutató modulja nem zárolja a munkameneteket. Zárolás nélkül a valós legrosszabb eset ez: egy ritka versenyhelyzetben a játékos elveszíti, amit a régi szerveren annak utolsó sikeres mentése után szerzett. Akkor adj hozzá zárolást, ha a duplázódás vagy a veszteség valami valódiba kerül a játékosoknak: csere, developer productok, ritka tárgyak vagy gyakori teleportok.

LehetőségMi ezAmit érdemes tudni
Az útmutató moduljaBetöltés, memóriabeli gyorsítótár, újrapróbálás, automentés, mentés leálláskor és sémaverziók, zárolás nélkülElég rövid ahhoz, hogy végigolvasd és módosítsd
A Roblox példája játékosadatokhoz és vásárlásokhozReferenciakód a Robloxtól munkamenet-zárolással, kulcsonként sorrendben végzett újrapróbálással és a vásárlási nyugták kezelésévelA Roblox szerint nincs kipróbálva egy népszerű játékban, és alapos tesztelés nélkül nem szabad változatlanul használni
ProfileStoreIngyenes, nyílt forráskódú közösségi modul, a ProfileService utódja, a munkamenet-zárolás és az automentés köré építveNem a Robloxtól. Egy meglévő játék átállítása a már mentett adatok migrálását igényli

Bármilyen külső modulnál a Roblox azt tanácsolja, hogy nézd meg, ki a tulajdonosa, karbantartják-e, és hogyan férsz hozzá az adataidhoz nélküle. Ugyanez a dokumentáció a DataStore2-t elavult könyvtárnak nevezi, amelyet új játékoknak nem érdemes használniuk.

Az adattárak korlátai

Ezek a Roblox dokumentációjában szereplő korlátok 2026. szeptember 30-i állapot szerint. A Roblox felülvizsgálja őket, ezért nézd meg a hibakódok és korlátok oldalát (angolul), mielőtt egy pontos számra építenél.

Alapértelmezett kéréskorlátok szerverenként, percenként
KéréstípusNormál tárakRendezett tárak
Olvasás: GetAsync, olvasás az UpdateAsync-ben60 + 40 × játékos60 + 40 × játékos
Írás: SetAsync, IncrementAsync, írás az UpdateAsync-ben60 + 40 × játékos30 + 5 × játékos
Listázás: ListKeysAsync, vagy GetSortedAsync rendezett tárakhoz5 + 2 × játékos5 + 2 × játékos
Törlés: RemoveAsync60 + 40 × játékos30 + 5 × játékos

20 játékosnál a szerver percenként 860 normál írást végezhet; ennek a modulnak az automentése ebből körülbelül 7-et használ, plusz egyet minden kilépő játékosra. A keretet az meríti ki, ha minden felvett érménél mentesz. Egy második keret az egész játékra vonatkozik, és az Open Clouddal közös: percenként 300 olvasás plusz 40 minden online játékosra, és 300 írás plusz 20 játékosonként.

Méret- és áteresztőképesség-korlátok
KorlátÉrték
Tár neve, kulcs neve, scopeEgyenként 50 karakter
Érték egy kulcsban4 194 304 karakter JSON formában
Egy kulcs olvasása az összes szerverrőlPercenként 25 MB
Írás egy kulcsba az összes szerverrőlPercenként 4 MB, minden kérés a következő KB-ra kerekítve felfelé
Függő kérésekSoronként 30; ezen felül a kérések 301-306-os hibákkal meghiúsulnak
Tárhely az egész játékra500 MB plusz 1 MB minden valaha volt felhasználóra

A játékosadatok méretét a #HttpService:JSONEncode(data) segítségével mérd, az élő szerver hátralévő keretét pedig a DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite) segítségével nézd meg. Azok a GetAsync hívások, amelyekre a 4 másodperces gyorsítótár válaszolt, nem számítanak. A Studio Run módjának saját, esetleg alacsonyabb korlátai vannak, ezért a kéréskorlátok teszteléséhez a Roblox a Team Create-et ajánlja.

Verziók és biztonsági mentések

A normál adattárak megőrzik helyetted az előzményeket. Egy kulcsba UTC szerint minden órában az első írás verzióként mentődik, az abban az órában következő írások pedig egymást írják felül. Egy régi verzió 30 nappal azután jár le, hogy egy újabb írás leváltotta; a legutolsó soha nem jár le. A rendezett tárak nem őriznek verziókat.

Egy játékos visszaállításához nyisd meg a Data Stores Manager felületet (Creations, a játékod, Configure > Data Stores Manager), válaszd ki a kulcsát, válassz egy korábbi verziót, és kattints a Revert gombra; ehhez Edit jogosultság kell. Akkor csináld, amikor a játékos nincs online, különben a munkamenetét tartó szerver a visszaállítás fölé menti a saját másolatát. Szerverscriptből a ListVersionsAsync és a GetVersionAsync megkeresi és kiolvassa a régi verziót, amelyet aztán aktuális értékként visszaírsz.

Mielőtt publikálnál egy frissítést, amely megváltoztatja az adatok mentésének módját, a Roblox azt tanácsolja, hogy készíts pillanatképet az Open Cloud Snapshot Data Stores API-val (játékonként naponta egyet). Enélkül egy hibás mentés 3:30 UTC-kor felülír mindent, amit 3:00 óta abba a kulcsba írtak, mert ugyanabba az órás verzióba kerül.

Gyakori hibák és megoldásaik

Az adattár-hibák a Studio Output ablakában jelennek meg, a modul pedig minden sikertelen kísérletnél kiír egy figyelmeztetést a Roblox hibaszövegével. A scripthibák útmutató elmagyarázza, hogyan kell egyáltalán olvasni az Outputot.

StudioAccessToApisNotAllowed (403-as hiba)

„Can't write to DataStore from Studio because API access is not enabled.” Publikáld a place-t, aztán kapcsold be az Enable Studio Access to API Services beállítást a File > Experience Settings > Security alatt, a tesztmásolatban.

DataStore request was added to queue

A szerver gyorsabban küldi a kéréseket, mint amit a kerete enged, vagy túl gyakran írja ugyanazt a kulcsot, általában azért, mert minden változáskor vagy egy ciklusban ment. Ha 30 kérés van a sorban, az újak 301-306-os hibákkal meghiúsulnak. Tartsd az adatokat a memóriában, és időzítve ments.

CantStoreValue (104-es hiba), vagy egy mező nil-ként tér vissza

A táblában van valami, amit a tár nem tud menteni, például Instance, Vector3 vagy Color3. Helyette nevet, azonosítót vagy egyszerű számokat ments, és betöltéskor állítsd vissza az objektumot.

ValueTooLarge (105-ös hiba)

Egy kulcs több mint 4 194 304 karakternyi JSON-t tárol. Mérd meg a #HttpService:JSONEncode(data) segítségével, vedd ki, amit újra elő lehet állítani, vagy oszd szét az adatokat több állandó kulcs között.

Nincs hiba, mégsem mentődnek az adatok

Keresd a modul Could not load figyelmeztetését: sikertelen betöltés után szándékosan nem hajlandó menteni. Ha nem ez, akkor az értéket valószínűleg egy LocalScriptben módosították, ami soha nem jut el a szerverig, vagy ugyanazt a kulcsot egy másik script menti.

Az adatok minden újracsatlakozáskor lenullázódnak

A kulcs munkamenetenként változik (a player.Name-ből áll össze, vagy megváltoztattad a STORE_NAME értékét), a betöltés nem sikerül, és az alapértékeket látod, vagy senki sem tölti be a modult, így egyáltalán nem fut. Nézd meg az Outputot, és azt, hogy a Main betölti-e a PlayerData-t.

Építsd meg a RoCode-dal

Ha nincs kedved kézzel összerakni, a RoCode megcsinálhatja közvetlenül a nálad nyitott place-ben. Ez egy független AI-ügynök, nem a Robloxtól, amely egy Roblox Studio pluginon keresztül dolgozik: olyan Luau kódot ír, amely bármely scripthez hasonlóan a DataStoreService-t használja, és scripteket hoz létre az Explorerben. Ő maga soha nem fér hozzá az adattáraidhoz, de a 3.9-es vagy újabb pluginnal megnyomhatja a Play gombot egy rövid playtesthez, amelyben a scriptjeid úgy futnak, mint bármely tesztben.

Te írod

Adj mentést a játékomhoz: tárold a Coins, Level és Inventory értékeket egy PlayerData modulban automentéssel és a szerver leállásakor végzett mentéssel, és mutasd a Coins értéket a már meglévő leaderstatsban.

A RoCode elvégzi
  • A Search Scripts és a Read Script segítségével megkeresheti a meglévő leaderstatsot és DataStore kódot, hogy azt bővítse, ami már megvan, és ne adjon hozzá egy második mentőscriptet. Egy nagy place-ben nevezd meg az üzenetben a scriptet vagy a mappát.
  • A Create Script segítségével létrehozza a ModuleScriptet és az azt betöltő Scriptet, vagy az Edit Script segítségével módosítja a meglévőket
  • Minden megírt scriptre lefuttatja a Check Scriptet: fordítási ellenőrzés a Studióban, rövid figyelmeztetéslistával, nem típusellenőrzés és nem tesztfuttatás
  • A változtatásokat csomagokban küldi, és minden csomag egy visszavonási (undo) pont a Studióban

A Studio Access to API Services bekapcsolását a tesztmásolatban így is neked kell elvégezned: a RoCode nem tudja megváltoztatni ezt a beállítást. A 3.9-es vagy újabb pluginnal a rövid playtestje kiolvassa a hibákat, a 3.9.11-es vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, hogy ellenőrizze, működik-e a játék, de csak azt ellenőrzi, amit ő maga eldöntött, ezért játssz te is, és győződj meg róla, hogy a Coins, Level és Inventory mentődik és betöltődik. Ha a mentés a te tesztedben nem sikerült, a Check Output kiolvashatja a Server sorokat az általad indított playtestből. A mentést általában akkor adják hozzá, amikor a fő játékciklus már működik; a Roblox játék készítése AI-val, egyszerre egy rendszerrel ezt a sorrendet mutatja be. Hogyan kapcsolódik a RoCode a Studióhoz.

Gyakori kérdések

Hogyan kapcsolom be a DataStore-t a Roblox Studióban?

Publikáld a place-t, nyisd meg a File > Experience Settings > Security részt, kapcsold be az Enable Studio Access to API Services beállítást, és kattints a Save gombra. Ezt egy külön tesztjátékban csináld, mert a Studio ekkor ugyanazokat az adattárakat használja, mint a játék élő szerverei.

Menti a Roblox automatikusan a játékos adatait?

Nem. A játékosról semmi sem marad meg a munkamenet után, ha egy szerverscript nem menti el a DataStoreService segítségével, és ez a leaderstatsra is igaz.

Mit válasszak: ProfileStore vagy közvetlenül DataStoreService?

A ProfileStore is adattárakra épül, így a kérdés az, hogy szeretnéd-e, hogy a munkamenet-zárolást más írja meg és tartsa karban helyetted. Cseréhez, fizetős tárgyakhoz vagy gyakori teleportokhoz megéri a zárolás, egy könyvtárból vagy a Roblox referenciapéldájából. Egy kisebb játékhoz egy ilyen modult könnyebb olvasni és módosítani.

Hogyan nullázom le vagy törlöm egy játékos adatait?

A Data Stores Managerben keresd meg a kulcsot, és válaszd a Mark for Deletion lehetőséget, amelyet a várakozási időn belül vissza lehet vonni, vagy hívd meg a RemoveAsync-et a kulcsra egy szerverscriptből. Akkor csináld, amikor a játékos nincs online, különben a szervere következő mentése visszaírja az adatokat. A tesztmásolatban a STORE_NAME megváltoztatása mindenkit nulláról indít; ezt soha ne csináld az élő játékban.

Források és további olvasnivaló

Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.