Tutoriaali · Pelaajan tiedot

Miten pelaajan tiedot tallennetaan Roblox Studiossa DataStorella

Roblox ei muista pelaajasta mitään pelikertojen välillä, ellei palvelinskripti ole tallentanut sitä. Tässä oppaassa kokoat PlayerData-moduulin, joka lataa, pitää muistissa ja tallentaa jokaisen pelaajan tiedot DataStoreServicellä, ja käyt sitten läpi testauksen, rajat ja sen, miten tallennetut tiedot katoavat.

Päivitetty 20. marraskuuta 202614 min lukuaikaKirjoittaja:

Lyhyesti

Käytä DataStoreServiceä palvelimen Scriptistä: lataa pelaajan tiedot GetAsync-kutsulla, kun hän liittyy, pidä ne taulukossa pelaamisen ajan ja tallenna UpdateAsync-kutsulla ajastimella, poistuttaessa (PlayerRemoving) ja palvelimen sammuessa (game:BindToClose). Kääri jokainen kutsu pcall-kutsuun ja yritä epäonnistuneita uudelleen muutaman kerran.

  • Testataksesi Studiossa julkaise paikka ja ota käyttöön File > Experience Settings > Security > Enable Studio Access to API Services erillisessä testipelissä: Studio käyttää samoja tietoja kuin julkaistut palvelimet.
  • Jos pelaajan tiedot eivät latautuneet, älä koskaan tallenna tätä pelaajaa. Oletusarvojen tallentaminen pyyhkii hänen todellisen etenemisensä.
  • Säilytä yksi taulukko pelaajaa kohden yhden avaimen alla, esimerkiksi User_12345, ja tallenna ajastimella, älä jokaisella muutoksella.
  • Esineiden vaihtoa tai maksullisia esineitä varten lisää istuntolukitus, jotta kaksi palvelinta ei voi tallentaa samaa pelaajaa.
Tällä sivulla
  1. Studion pääsy
  2. Miten DataStore toimii
  3. GetAsync ja UpdateAsync
  4. 1. PlayerData-moduuli
  5. Miten moduuli toimii
  6. 2. Tietojen käsittely
  7. 3. Varoitus
  8. 4. Testaus Studiossa
  9. Miksi tiedot katoavat
  10. Istuntolukitus
  11. Rajat
  12. Versiot ja kopiot
  13. Common errors
  14. With RoCode
  15. Usein kysytyt kysymykset
  16. Lähteet ja lisälukemista

Ennen aloittamista: ota Studion pääsy käyttöön testikopiossa

Studiossa käynnistetty peli ei voi käyttää tietovarastoja ennen kuin sallit sen. Luvassa on ansa, josta Robloxin dokumentaatio varoittaa: Studio lukee ja kirjoittaa silloin samoja tietovarastoja kuin julkaistu peli, joten testi, joka nollaa kolikkosi Studiossa, nollaa ne myös julkaistussa pelissä, ja testikoodin virhe voi pilata oikeiden pelaajien avaimet.

  1. Tee testikopio. Tallenna paikka tiedostoon, avaa kopio, valitse File > Publish to Roblox As ja paina Create new game. Älä lisää sitä paikaksi julkaistun pelin sisään: kaikki saman pelin paikat jakavat samat tietovarastot.
  2. Avaa testikopiossa File > Experience Settings ja siirry kohtaan Security.
  3. Ota käyttöön Enable Studio Access to API Services ja paina Save.

Tietovarastokutsut toimivat vain palvelimen Scripteissä; LocalScript, joka yrittää, saa virheen, joten asiakkaat eivät voi kirjoittaa tallennettuja tietoja. Kun painikkeen pitää muuttaa niitä, asiakas pyytää palvelinta RemoteEventillä, ja palvelin päättää (katso RemoteEvent-opas, englanniksi).

Miten tietovarastot säilyttävät pelaajien tietoja

HavainnollistusOppaan vaiheen 4 testi nopeutettuna: Play, Stop tallentaa istunnon tietovarastoon, uusi Play lataa sen, joten Output näyttää 200.

Tietovarasto (data store) on nimetty avain-arvojoukko Robloxin palvelimilla, yhteinen kaikille pelisi palvelimille ja paikoille. DataStoreService:GetDataStore("PlayerData") palauttaa yhden tällaisen varaston.

Robloxin suositukset tiivistyvät sääntöön yksi varasto pelaajien tiedoille, yksi avain pelaajaa kohden, yksi taulukko jokaisessa avaimessa. Muodosta avain pelaajan UserId-arvosta, esimerkiksi User_12345, äläkä koskaan nimestä, jonka hän voi vaihtaa. Pysyvä malli User_{UserId} antaa myös Robloxin automaattisen oikeus tulla unohdetuksi -käsittelyn löytää pelaajan tiedot, jos otat sen käyttöön.

Mitä tietovarastoon voi tallentaa
TyyppiTallentuuko?Huomioita
Luvut, merkkijonot, totuusarvot, puskuritKylläMerkkijonojen täytyy olla kelvollista UTF-8:aa. Älä tallenna arvoja inf tai nan.
TaulukotKylläJos kaikki sisällä oleva on myös tallennettavissa. Taulukko, jonka numeroavaimet eivät ala 1:stä (joten sen pituus on 0), palautuu näiden avainten ollessa merkkijonoja.
Instance, Vector3, CFrame, Color3EiTallennus antaa virheen tai kirjoittaa nil. Tallenna esineen nimi tai sijainti kolmena lukuna.

Jokainen pyyntö on verkkokutsu, joka voi epäonnistua, vie aikaa ja kuluttaa minuuttikohtaista budjettia. Siksi luotettavat tallennusjärjestelmät lukevat tiedot kerran pelaajan liittyessä, pitävät ne palvelimen taulukossa pelaamisen ajan ja kirjoittavat ne takaisin aika ajoin.

GetAsync, SetAsync vai UpdateAsync: mikä valita

Tietovaraston päämetodit
MetodiMitä se tekeeMihin
GetAsync(key)Lukee arvon. Tulos välimuistitetaan tällä palvelimella 4 sekunniksi.Pelaajan tietojen lataaminen
SetAsync(key, value)Korvaa arvon lukematta sitä. Yksi kirjoitus.Uusi avain tai arvo, joka ei riipu vanhasta
UpdateAsync(key, callback)Lukee viimeisimmän arvon, välittää sen funktiollesi ja kirjoittaa sen, minkä funktio palauttaa. Yksi luku ja yksi kirjoitus.Pelaajan tietojen tallennus ja mikä tahansa avain, jota useampi palvelin voi kirjoittaa
IncrementAsync(key, delta)Lisää kokonaisluvun tallennettuun kokonaislukuun.Laskurit
RemoveAsync(key)Poistaa avaimen ja palauttaa vanhan arvon. Aiemmat versiot voi edelleen luetella ja lukea.Pelaajan tietojen poistaminen

SetAsync kirjoittaa sokeasti: jos kaksi palvelinta tallentaa saman avaimen lähes yhtä aikaa, viimeinen kirjoitus voittaa, oli siinä mitä tahansa. UpdateAsync lukee ensin nykyisen arvon, ja jos toinen palvelin kirjoittaa välissä, Roblox ajaa funktiosi uudelleen uudella arvolla. Roblox suosittelee sitä aina, kun kirjoitus riippuu nykyisestä arvosta tai useampi palvelin voi kirjoittaa avaimen, ja juuri sellaisia pelaajan tiedot ovat. Funktiolla on kolme sääntöä:

  • Se ei saa luovuttaa suoritusta (yield): ei task.wait()-kutsuja eikä muita varastokutsuja sisällä.
  • Se voidaan suorittaa useammin kuin kerran, joten sen pitää vain laskea uusi arvo eikä koskaan antaa esineitä tai laukaista tapahtumia.
  • nil-palautus peruu kirjoituksen. Moduuli käyttää tätä, jottei se korvaa pelin uudemman version tallentamia tietoja.

Vaihe 1: luo PlayerData-moduuli

Tämä ModuleScript on ainoa koodi, joka keskustelee tietovaraston kanssa. Se lataa pelaajan tiedot liittyessä, pitää ne muistissa, tallentaa 180 sekunnin välein, poistuttaessa ja palvelimen sammuessa ja kieltäytyy tallentamasta niitä, joiden tiedot eivät latautuneet.

  1. Vie Explorerissa osoitin ServerScriptServicen päälle, paina + ja lisää ModuleScript. Nimeä se uudelleen PlayerData ja korvaa sisältö alla olevalla koodilla.
  2. ModuleScript suoritetaan vain, kun jokin skripti ottaa sen käyttöön (require). Lisää ServerScriptServiceen Script nimeltä Main, jossa on tämä rivi: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Muut palvelinskriptit ottavat sen käyttöön samoin.
  3. Muuta DEFAULTS ja Data-tyyppi pelisi mukaisiksi pitäen jokaisen kentän lukuna, merkkijonona, totuusarvona tai taulukkona.
Explorer vaiheiden 1-3 jälkeen
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript kohteessa ServerScriptService nimeltä PlayerData
-- PlayerData: lataa pelaajan tiedot liittyessä, pitää ne muistissa
-- ja tallentaa ajastimella, poistuttaessa ja palvelimen sammuessa.
-- Muut palvelinskriptit lukevat ja muuttavat niitä PlayerData.Get(player)-kutsulla.

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

local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- kasvata, kun tietojen muoto muuttuu, ja lisää vaihe migrate()-funktioon
local AUTOSAVE_SECONDS = 180
-- Studiossa epäonnistunut kutsu luovuttaa heti, joten testi ilman varastopääsyä on nopea
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- tuplaantuu jokaisen epäonnistumisen jälkeen: 1, 2, 4

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

-- Millä aivan uusi pelaaja aloittaa
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- false, jos lataus epäonnistui: oletustiedot eivät saa korvata todellista etenemistä
}

-- Kutsutaan jokaisen alla olevan pcallin sisällä, joten vielä julkaisematon paikka
-- (ilman varastopääsyä) lataa silti pelaajat oletustiedoilla
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- vielä käynnissä olevat tallennukset avaimittain
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- Laukeaa pelaajan kanssa, kun hänen tietonsa ovat valmiit. Hae taulukko PlayerData.Get(player)-kutsulla:
-- BindableEventillä lähetetty taulukko saapuu kopiona, eikä sen muuttaminen muuta mitään.
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) -- tuore kopio, jotta pelaajat eivät koskaan jaa samaa Inventory-taulukkoa
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- Tuo tallennetut tiedot nykyiseen skeemaan. Palauttaa nil, jos niitä ei voi käyttää turvallisesti.
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 -- tallennettu pelin uudemmalla versiolla: älä lataa äläkä korvaa tässä
	end

	-- Yksi vaihe skeeman muutosta kohden, vanhoista uusiin
	if version < 2 then
		-- Esimerkki: versiossa 1 valuutan nimi oli Gold. Kopioidaan se vain, jos Coinsia ei ole,
		-- jotta vanhat tiedot, joissa Coins jo on mutta SchemaVersion puuttuu, säilyttävät arvonsa.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Lisätään kentät, jotka tulivat pelaajan viimeisimmän tallennuksen jälkeen, ja korvataan väärän tyyppiset arvot
	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

-- Suorittaa varastokutsun pcallissa. Epäonnistuessa odottaa ja yrittää uudelleen tuplaten joka kerta
-- odotuksen ja lisäten hieman satunnaisuutta, jotta palvelimet eivät yritä uudelleen kaikki kerralla.
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 -- nil-palautus peruu kirjoituksen
			end
			-- Kirjoitetaan koko nykyinen taulukko pelaajan UserId-merkinnällä
			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()
		-- Aloitetaan satunnaisessa kohdassa väliä, jotta palvelimet eivät tallenna kaikki kerralla
		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

	-- Jos pelaaja juuri poistui tältä palvelimelta ja palasi, annetaan ensin viimeisen tallennuksen päättyä
	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 -- poistui latauksen aikana: mikään ei muuttunut, ei mitään tallennettavaa
	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) -- GUI voi lukea tämän ja varoittaa pelaajaa
	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 -- pysäyttää automaattitallennuksen silmukan, eikä toinen kutsu tee mitään
	save(session)
end

-- Pelaajan elävä tietotaulukko tai nil, kunnes se on latautunut. Muuta sitä vain palvelinskripteistä.
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True, kun pelaajan tiedot latautuivat ja ne tallennetaan. Tarkista ennen mitä tahansa myyntiä.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Tallentaa nyt odottamatta ajastinta tärkeissä hetkissä, kuten oston jälkeen.
-- Luovuttaa suorituksen ja palauttaa true, kun tallennus onnistui.
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) -- pelaajat, jotka liittyivät ennen tämän moduulin ensimmäistä käyttöönottoa
end

game:BindToClose(function()
	-- Palvelin antaa näille funktioille 30 sekuntia, joten tallennetaan kaikki yhtä aikaa
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Sitten odotetaan kaikkia yhä käynnissä olevia tallennuksia, myös PlayerRemovingissa aloitettuja
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

Kun peli on julkaistu, älä muuta STORE_NAME-arvoa äläkä avaimen mallia User_. Kumman tahansa muuttaminen ohjaa moduulin tyhjiin avaimiin, ja jokainen pelaaja aloittaa alusta oletusarvoilla.

Miten moduuli suojelee tietoja

Oletusarvot ja skeeman versio

Uusi pelaaja saa tuoreen kopion DEFAULTS-taulukosta. Sen täytyy olla nimenomaan kopio: jos kaikki pelaajat jakaisivat saman Inventory-taulukon, yhdelle lisätty esine ilmestyisi kaikille.

Jokaisessa tallennetussa taulukossa on SchemaVersion. Kentän lisääminen ei vaadi uutta versiota, koska migrate täyttää puuttuvat kentät oletusarvoista. Uudelleennimeäminen tai uudelleenjärjestely vaatii: kasvata SCHEMA_VERSION-arvoa ja lisää vaihe, kuten esimerkissä, joka nimeää Goldin uudelleen Coinsiksi (uudessa pelissä poista se ja aloita 1:stä). Tiedot, joiden versio on palvelimen versiota korkeampi, tulivat uudemmasta julkaisusta, joka on vielä levittymässä, joten vanhat palvelimet eivät koske niihin.

Epäonnistunutta latausta ei koskaan tallenneta

Tämä sääntö suojaa täydeltä pyyhkiytymiseltä. Jos kaikki latausyritykset epäonnistuivat, pelaaja pelaa oletustiedoilla, mutta canSave on false, joten nämä arvot eivät koskaan korvaa hänen todellista etenemistään. Moduuli asettaa myös attribuutin DataLoaded arvoon false, ja vaihe 3 käyttää sitä kertoakseen pelaajalle. Robloxin mallitoteutus käsittelee epäonnistuneet lataukset samoin ja ehdottaa tätä potkimisen sijaan; jos haluat mieluummin potkia, kutsu player:Kick() viestillä kohdassa, jossa moduuli tulostaa varoituksen.

Uusinnat kasvavalla tauolla

withRetries käärii jokaisen kutsun pcall-kutsuun. Epäonnistumisen jälkeen se odottaa 1, sitten 2, sitten 4 sekuntia, joka kerta lisäten satunnaisesti enintään puolet tästä ajasta, ja lopettaa neljän yrityksen jälkeen (Studiossa yhden jälkeen, jotta paikka ilman varastopääsyä käynnistyy heti). Satunnaisuus hajauttaa monen palvelimen uusinnat katkon jälkeen, ja rajoitus pitää odotuksen noin 10 sekunnissa, 30 sekunnin sisällä, jotka palvelin saa sammumiseen. Koska jokainen tallennus kirjoittaa koko elävän taulukon UpdateAsyncilla, myöhässä päättynyt uusinta ei voi palauttaa vanhoja tietoja.

Milloin moduuli tallentaa

MilloinMiksi
180 sekunnin välein pelaajan ollessa palvelimellaRajoittaa menetyksiä kaatumisessa. Ensimmäinen tallennus osuu satunnaiseen kohtaan väliä, jotta palvelimet eivät tallenna kaikki kerralla. Robloxin mallitoteutuskin käyttää 180 sekuntia.
Kun pelaaja poistuu (PlayerRemoving)Tavallinen viimeinen tallennus. Istunto poistetaan ensin, joten automaattitallennus pysähtyy.
Kun palvelin sammuu (game:BindToClose)Kaikki palvelimella vielä olevat tallennetaan kerralla, ja funktio odottaa jokaista käynnissä olevaa tallennusta. Roblox antaa sille 30 sekuntia.
Pyynnöstä, PlayerData.SaveNow(player)-kutsullaJonkin sellaisen jälkeen, mitä ei saa menettää, kuten oston.

Jos pelaaja liittyy uudelleen samalle palvelimelle, kun hänen viimeinen tallennuksensa on vielä käynnissä, uusi lataus odottaa tämän tallennuksen päättymistä, joten se ei voi lukea vanhaa arvoa.

Vaihe 2: lue ja muuta tietoja muista skripteistä

Kaikki moduulin käyttöön ottavat palvelinskriptit käsittelevät samoja taulukoita:

KutsuMitä se tekee
PlayerData.Get(player)Pelaajan elävä tietotaulukko tai nil, kunnes se on latautunut. Muuta kenttiä suoraan, esimerkiksi data.Coins += 10, niin seuraava tallennus ottaa sen mukaan.
PlayerData.LoadedLaukeaa pelaajan kanssa, kun hänen tietonsa ovat valmiit, myös epäonnistuneen latauksen jälkeen. Välittää vain pelaajan, koska BindableEventillä lähetetty taulukko saapuu kopiona.
PlayerData.CanSave(player)false, jos lataus epäonnistui. Tarkista ennen mitä tahansa myyntiä: osto, jota ei voi tallentaa, katoaa pelaajan poistuessa.
PlayerData.SaveNow(player)Tallentaa heti ja palauttaa true, jos se onnistui. Luovuttaa suorituksen.

Moduuli on ainoa paikka, jossa tallennetut tiedot elävät, ja leaderstats on vain näyttö: kokoa se kuten tulostaulukko-oppaassa, täytä se PlayerData.Get(player)-kutsulla Loaded-käsittelijässä ja päivitä molemmat arvon muuttuessa. Älä koskaan lue tallennettuja arvoja takaisin leaderstatsista äläkä koskaan anna toisen skriptin tallentaa samaa avainta.

Skripti, joka otti moduulin käyttöön pelaajien liityttyä, ohittaa heidän Loaded-tapahtumansa. Kytke käsittelijä ja käy sitten lisäksi silmukassa läpi Players:GetPlayers() ja käsittele kaikki, joille PlayerData.Get(player) jo palauttaa taulukon.

Korvaatko vanhan tallennusskriptin, esimerkiksi tulostaulukko-oppaasta? Sen arvot jäävät sen omaan varastoon ja avaimeen, joten tämä moduuli aloittaa kaikki oletusarvoista. Ennen julkaisua joko ohjaa STORE_NAME ja etuliite User_ vanhoihin (migrate pitää tietoja ilman SchemaVersionia versiona 1 ja täyttää puuttuvat kentät) tai siirrä vanhat arvot ja poista sitten vanha skripti.

Asiakkaat eivät koskaan muuta näitä tietoja suoraan. Kaupan painike laukaisee RemoteEventin; palvelin tarkistaa CanSaven, vertaa hintaa pelaajan Coinsiin, muuttaa taulukkoa ja kutsuu SaveNow. Kaupan GUI -opas kokoaa tällaisen oston palvelimen puolella.

Valmis esimerkki kenttien lisäämisestä on klikkerisimulaattorioppaassa: se lisää PowerLevelin ja Rebirthsin DEFAULTS-taulukkoon ja Data-tyyppiin ja muuttaa niitä sitten taulukossa, jonka PlayerData.Get palauttaa. migrate antaa uudet kentät pelaajille, joilla on vanhat tallennukset.

Vaihe 3: kerro pelaajalle, etteivät hänen tietonsa latautuneet

Pelaajan, jonka tiedot eivät latautuneet, täytyy tietää, ettei tämä istunto tallennu, jotta hän liittyy uudelleen eikä pelaa turhaan. Tämä LocalScript seuraa DataLoaded-attribuuttia ja näyttää bannerin, kun se on false.

LocalScript kohteessa StarterPlayerScripts nimeltä 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

-- Palvelin asettaa DataLoadedin kerran, yritettyään ladata tämän pelaajan tiedot
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

Vaihe 4: testaa tallennus Studiossa

Tee tämä testikopiossa, jossa Studion pääsy on käytössä.

  1. Anna itsellesi jotain tallennettavaa. Lisää Mainin require-rivin alle: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Paina Play. Output-ikkuna (Window-valikossa tai Script-välilehdellä) näyttää nimesi ja 100 (ensimmäisellä kerralla) ilman Could not load -varoitusta.
  3. Paina Stop. Testin päättäminen sulkee palvelimen, ja moduuli tallentaa sinut ennen sulkemista.
  4. Paina uudelleen Play. Outputin pitäisi näyttää 200, 100 enemmän kuin viime kerralla. Jos se näyttää taas saman luvun, tallennus ei onnistunut: lue sen yläpuolella olevat varoitukset.
  5. Testaa virhepolku. Poista Studion pääsy käytöstä ja paina Play. Muutaman sekunnin uusintojen jälkeen Output näyttää Could not load User_... ja 100, ja vaiheen 3 banneri ilmestyy. Pysäytä testi, ota pääsy uudelleen käyttöön ja paina Play: Output näyttää 300, tallennetut 200 plus 100, koska epäonnistunut istunto ei koskaan korvannut tietojasi.
  6. Poista testirivi Mainista.

Miksi pelaajien tiedot katoavat

Nämä ovat tavallisia tapoja, joilla tallennusjärjestelmä menettää etenemistä. Moduuli hoitaa koodissa neljä ensimmäistä riviä ja skeemaa koskevan rivin; muut riippuvat siitä, mitä ja miten tallennat, ja viimeiseen tarvitaan istuntolukitus.

Mitä tapahtuuTulosMiten estetään
Lataus epäonnistui, mutta skripti tallentaa siltiOletusarvot pyyhkivät todellisen etenemisen: täydellinen pyyhkiytyminenÄlä koskaan tallenna pelaajaa, jonka lataus epäonnistui
Tallennus vain PlayerRemovingissaPalvelimen kaatuminen tai sammuminen ohittaa tallennuksenAutomaattitallennus sekä BindToClose, joka odottaa tallennuksiaan
Ei pcallia tai ei uusintaaYksi epäonnistunut pyyntö pysäyttää skriptin tai menettää tallennuksenpcall ja muutama ajallisesti hajautettu uusinta
Tallennus jokaisella muutoksellaPyynnöt jonoutuvat; kun jonossa on 30, uudet hylätäänPidä tiedot muistissa ja tallenna ajastimella
Sellaisen tallentaminen, mitä varasto ei osaa säilyttääTallennus antaa virheen, tai arvo palautuu nil-arvonaTallenna lukuja, merkkijonoja, totuusarvoja ja niistä koostuvia taulukoita
Tietojen muodon muuttaminen ilman migraatiotaVanhat tallennukset latautuvat vääriin kenttiinSkeeman versio ja migraatiovaihe
Kaksi skriptiä tallentaa samaa avaintaKumpikin tallennus pyyhkii toisen kentätAvaimen omistaa yksi moduuli
Kaksi palvelinta pitää samaa pelaajaaVanhoilla tiedoilla oleva palvelin tallentaa viimeisenä ja pyyhkii uuden etenemisenIstuntolukitus

Istuntolukitus, ”lock lost” ja ProfileStore

Pelaaja on yhdistettynä yhteen palvelimeen kerrallaan, mutta vanhan palvelimen viimeinen tallennus voi olla vielä käynnissä, kun hän liittyy uudelle: hidas uusinta, teleportti tai nopea uudelleenliittyminen. Jos uusi palvelin lataa tiedot ensin, sillä on vanhat tiedot, ja voittaja on se palvelin, joka tallentaa viimeisenä. Robloxin dokumentaatio huomauttaa, että vaihtokauppapeleissä tämä aukko on yleinen esineiden monistumisen syy.

Istuntolukitus sulkee tämän aukon. Kun palvelin lataa pelaajan avaimen, se kirjoittaa samassa UpdateAsync-kutsussa lukitustunnuksensa avaimen metatietoihin. Mikä tahansa toinen palvelin, joka löytää vanhentumattoman lukituksen, jota se ei itse asettanut, ei lataa eikä tallenna tätä avainta. Omistaja uusii lukituksen jokaisessa automaattitallennuksessa ja poistaa sen viimeisessä tallennuksessa; jos se lakkaa uusimasta sitä, lukitus vanhenee, ja toinen palvelin voi ottaa sen.

Mitä ”lock lost” tarkoittaa

Istuntolukitusta käyttävässä järjestelmässä palvelin on menettänyt lukituksen, kun pelaajan avaimen omistaa nyt toinen palvelin, koska lukitus vanheni tai kaapattiin. Sen kopio voi olla vanhentunut, joten sen täytyy lopettaa tämän pelaajan tallentaminen; tavallinen reaktio on potkia hänet viestillä, jotta hän yhdistää uudelleen. Jos näit ”lock lost” -viestin pelaajana, se on kyseisen pelin oman tallennusjärjestelmän viesti, ja sen voivat selittää vain pelin kehittäjät.

Tarvitsetko sitä?

Tämän oppaan moduuli ei lukitse istuntoja. Ilman lukitusta todellinen pahin tapaus on tämä: harvinaisessa kilpatilanteessa pelaaja menettää sen, minkä ansaitsi vanhalla palvelimella sen viimeisen onnistuneen tallennuksen jälkeen. Lisää lukitus, kun monistuminen tai menetys maksaa pelaajille jotain todellista: vaihtokauppa, developer productit, harvinaiset esineet tai tiheät teleportit.

VaihtoehtoMikä se onMitä kannattaa tietää
Tämän oppaan moduuliLataus, välimuisti muistissa, uusinnat, automaattitallennus, tallennus sammuttaessa ja skeemaversiot, ilman lukitustaTarpeeksi lyhyt luettavaksi kokonaan ja muutettavaksi
Robloxin esimerkki pelaajatiedoille ja ostoilleRobloxin mallikoodi istuntolukituksella, avainkohtaisilla järjestyksessä tehtävillä uusinnoilla ja ostokuittien käsittelylläRobloxin mukaan sitä ei ole koeteltu suositussa pelissä, eikä sitä pidä käyttää sellaisenaan ilman laajaa testausta
ProfileStoreIlmainen avoimen koodin yhteisömoduuli, ProfileServicen seuraaja, joka on rakennettu istuntolukituksen ja automaattitallennuksen ympärilleEi Robloxin tekemä. Olemassa olevan pelin siirtäminen siihen vaatii jo tallennettujen tietojen migraation

Minkä tahansa kolmannen osapuolen moduulin kohdalla Roblox neuvoo tarkistamaan, kuka sen omistaa, ylläpidetäänkö sitä ja miten pääset tietoihisi ilman sitä. Sama dokumentaatio kutsuu DataStore2:ta vanhentuneeksi kirjastoksi, jota uusien pelien ei kannata käyttää.

Tietovarastojen rajat

Nämä ovat Robloxin dokumentaation rajat 30. syyskuuta 2026. Roblox tarkistaa niitä, joten katso virhekoodien ja rajojen sivu (englanniksi) ennen kuin luotat tarkkaan lukuun.

Pyyntöjen oletusrajat palvelinta kohden minuutissa
Pyynnön tyyppiTavalliset varastotJärjestetyt varastot
Luku: GetAsync, luku UpdateAsyncissa60 + 40 × pelaajat60 + 40 × pelaajat
Kirjoitus: SetAsync, IncrementAsync, kirjoitus UpdateAsyncissa60 + 40 × pelaajat30 + 5 × pelaajat
Luettelo: ListKeysAsync tai GetSortedAsync järjestetyille varastoille5 + 2 × pelaajat5 + 2 × pelaajat
Poisto: RemoveAsync60 + 40 × pelaajat30 + 5 × pelaajat

20 pelaajalla palvelin voi tehdä 860 tavallista kirjoitusta minuutissa; tämän moduulin automaattitallennus kuluttaa niistä noin 7 sekä yhden jokaista poistuvaa pelaajaa kohden. Budjetin kuluttaa loppuun tallennus jokaisesta poimitusta kolikosta. Toinen budjetti koskee koko peliä ja jaetaan Open Cloudin kanssa: 300 lukua minuutissa plus 40 jokaista paikalla olevaa pelaajaa kohden ja 300 kirjoitusta plus 20 pelaajaa kohden.

Koko- ja kaistarajat
RajaArvo
Varaston nimi, avaimen nimi, scopeKukin 50 merkkiä
Arvo yhdessä avaimessa4 194 304 merkkiä JSONina
Yhden avaimen luku kaikilta palvelimilta25 Mt minuutissa
Kirjoitus yhteen avaimeen kaikilta palvelimilta4 Mt minuutissa, jokainen pyyntö pyöristetään ylös seuraavaan kt:hen
Odottavat pyynnöt30 jonoa kohden; sen yli pyynnöt epäonnistuvat virheillä 301-306
Koko pelin tallennustila500 Mt plus 1 Mt jokaista kaikkien aikojen käyttäjää kohden

Mittaa pelaajan tietojen koko #HttpService:JSONEncode(data)-kutsulla ja katso julkaistun palvelimen jäljellä oleva budjetti kutsulla DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite). GetAsync-kutsuja, joihin 4 sekunnin välimuisti vastasi, ei lasketa. Studion Run-tilalla on omat, mahdollisesti matalammat rajansa, joten pyyntörajojen testaamiseen Roblox neuvoo Team Createa.

Versiot ja varmuuskopiot

Tavalliset tietovarastot säilyttävät historian puolestasi. Ensimmäinen kirjoitus avaimeen kunkin UTC-tunnin aikana tallennetaan versiona, ja saman tunnin myöhemmät kirjoitukset korvaavat toisensa. Vanha versio vanhenee 30 päivää sen jälkeen, kun uudempi kirjoitus korvasi sen; viimeisin ei vanhene koskaan. Järjestetyt varastot eivät säilytä versioita.

Palauttaaksesi yhden pelaajan avaa Data Stores Manager (Creations, pelisi, Configure > Data Stores Manager), valitse hänen avaimensa, valitse aiempi versio ja paina Revert; tähän tarvitaan Edit-oikeus. Tee tämä, kun pelaaja ei ole paikalla, muuten hänen istuntonsa palvelin tallentaa kopionsa palautuksen päälle. Palvelinskriptistä ListVersionsAsync ja GetVersionAsync löytävät ja lukevat vanhan version, jonka sitten kirjoitat takaisin nykyiseksi arvoksi.

Ennen päivityksen julkaisemista, joka muuttaa tietojen tallennustapaa, Roblox neuvoo ottamaan tilannekuvan Open Cloud Snapshot Data Stores API:lla (yksi päivässä peliä kohden). Ilman sitä virheellinen tallennus klo 3:30 UTC pyyhkii kaiken, mitä tähän avaimeen on kirjoitettu klo 3:00 jälkeen, koska se osuu samaan tuntiversioon.

Yleiset virheet ja ratkaisut

Tietovarastojen virheet näkyvät Studion Output-ikkunassa, ja moduuli tulostaa varoituksen Robloxin virhetekstillä jokaisesta epäonnistuneesta yrityksestä. Skriptivirheopas selittää, miten Outputia ylipäätään luetaan.

StudioAccessToApisNotAllowed (virhe 403)

”Can't write to DataStore from Studio because API access is not enabled.” Julkaise paikka ja ota sitten testikopiossa käyttöön Enable Studio Access to API Services kohdassa File > Experience Settings > Security.

DataStore request was added to queue

Palvelin lähettää pyyntöjä nopeammin kuin budjetti sallii tai kirjoittaa yhtä avainta liian usein, yleensä tallennuksen takia jokaisella muutoksella tai silmukassa. Kun jonossa on 30 pyyntöä, uudet epäonnistuvat virheillä 301-306. Pidä tiedot muistissa ja tallenna ajastimella.

CantStoreValue (virhe 104), tai kenttä palautuu nil-arvona

Taulukossa on jotain, mitä varasto ei osaa tallentaa, kuten Instance, Vector3 tai Color3. Tallenna sen sijaan nimi, ID tai yksinkertaisia lukuja ja palauta objekti latauksessa.

ValueTooLarge (virhe 105)

Yksi avain säilyttää yli 4 194 304 merkkiä JSONia. Mittaa #HttpService:JSONEncode(data)-kutsulla, poista se, minkä voi palauttaa, tai jaa tiedot useaan pysyvään avaimeen.

Virheitä ei ole, mutta tiedot eivät tallennu

Etsi moduulin Could not load -varoitusta: epäonnistuneen latauksen jälkeen se tarkoituksella kieltäytyy tallentamasta. Muuten arvoa luultavasti muutettiin LocalScriptissä, mikä ei koskaan mene palvelimelle, tai samaa avainta tallentaa toinen skripti.

Tiedot nollautuvat jokaisella uudelleenliittymisellä

Avain muuttuu istuntojen välillä (muodostettu player.Name-arvosta, tai muutit STORE_NAME-arvoa), lataus epäonnistuu ja näet oletusarvot, tai kukaan ei ota moduulia käyttöön, eikä se toimi lainkaan. Tarkista Output ja se, että Main ottaa PlayerDatan käyttöön.

Rakenna tämä RoCodella

Jos et halua koota tätä käsin, RoCode voi tehdä sen suoraan paikkaan, joka sinulla on auki. Se on itsenäinen tekoälyagentti, ei Robloxin tekemä, joka toimii Roblox Studio -lisäosan kautta: se kirjoittaa Luauta, joka käyttää DataStoreServiceä kuten mikä tahansa skripti, ja luo skriptit Exploreriisi. Itse se ei koskaan käytä tietovarastojasi, mutta lisäosalla 3.9 tai uudemmalla se voi painaa Play lyhyttä pelitestiä varten, jossa skriptisi toimivat kuten missä tahansa testissä.

Sinä kirjoitat

Lisää peliini tallennus: säilytä Coins, Level ja Inventory PlayerData-moduulissa automaattitallennuksella ja tallennuksella palvelimen sammuessa ja näytä Coins leaderstatsissa, joka minulla jo on.

RoCode tekee
  • Voi etsiä olemassa olevat leaderstatsit ja DataStore-koodin Search Scriptsillä ja Read Scriptillä laajentaakseen sitä, mitä sinulla on, eikä lisätäkseen toista tallennusskriptiä. Isossa paikassa nimeä skripti tai kansio viestissä.
  • Luo ModuleScriptin ja sen käyttöön ottavan Scriptin Create Scriptillä tai muuttaa olemassa olevia Edit Scriptillä
  • Ajaa Check Scriptin jokaiselle kirjoitetulle skriptille: käännöstarkistuksen Studion sisällä lyhyellä varoitusluettelolla, ei tyyppitarkistusta eikä testiajoa
  • Lähettää muutokset erinä, ja jokainen erä on kumouspiste (undo) Studiossa

Studio Access to API Servicesin käyttöönotto testikopiossa jää silti sinulle: RoCode ei voi muuttaa tätä asetusta. Lisäosalla 3.9 tai uudemmalla sen lyhyt pelitesti lukee virheet, ja lisäosalla 3.9.11 tai uudemmalla se voi ohjata testihahmoa tarkistaakseen, että peli toimii, mutta se tarkistaa vain sen, mitä se itse päätti tarkistaa, joten pelaa itse ja varmista, että Coins, Level ja Inventory tallentuvat ja latautuvat. Jos tallennus ei onnistunut testissäsi, Check Output voi lukea käynnistämäsi pelitestin Server-rivit. Tallennus lisätään yleensä, kun pääpelisilmukka jo toimii; Roblox-pelin luominen tekoälyllä järjestelmä kerrallaan näyttää tämän järjestyksen. Miten RoCode yhdistyy Studioon.

Usein kysytyt kysymykset

Miten DataStore otetaan käyttöön Roblox Studiossa?

Julkaise paikka, avaa File > Experience Settings > Security, ota käyttöön Enable Studio Access to API Services ja paina Save. Tee tämä erillisessä testipelissä, koska Studio käyttää silloin samoja tietovarastoja kuin pelin julkaistut palvelimet.

Tallentaako Roblox pelaajan tiedot automaattisesti?

Ei. Mitään pelaajasta ei tallenneta istunnon jälkeen, ellei palvelinskripti tallenna sitä DataStoreServicellä, ei myöskään leaderstatsia.

Kumpi valita: ProfileStore vai DataStoreService suoraan?

ProfileStorekin on rakennettu tietovarastojen päälle, joten kysymys on siitä, haluatko istuntolukituksen kirjoitettuna ja ylläpidettynä puolestasi. Vaihtokauppaan, maksullisiin esineisiin tai tiheisiin teleportteihin lukitus kannattaa, kirjastosta tai Robloxin mallitoteutuksesta. Pienempään peliin tämän kaltainen moduuli on helpompi lukea ja muuttaa.

Miten pelaajan tiedot nollataan tai poistetaan?

Etsi avain Data Stores Managerissa ja valitse Mark for Deletion, jonka voi perua odotusajan kuluessa, tai kutsu palvelinskriptistä avaimen RemoveAsync. Tee tämä, kun pelaaja ei ole paikalla, muuten hänen palvelimensa seuraava tallennus kirjoittaa tiedot takaisin. Testikopiossa STORE_NAME-arvon vaihtaminen aloittaa kaikki alusta; älä koskaan tee tätä julkaistussa pelissä.

Lähteet ja lisälukemista

Miten koodi tarkistettiin: jokainen tämän sivun skripti läpäisee Luaun tiukan tyyppitarkistuksen Roblox API:n määrittelyillä (luau-lsp, 20. marraskuuta 2026). Tyyppitarkistus löytää virheet API-nimissä ja väärät tyypit, mutta ei pelilogiikan virheitä, joten testaa kaikki Studiossa ennen julkaisua.

Kokeile RoCodea omassa pelissäsi.

Ilmaisia krediittejä joka päivä, ei korttia. Asenna lisäosa, kuvaile ominaisuus ja katso, mitä Studioon ilmestyi.