Tutorial · Datos del jugador

Cómo guardar los datos del jugador en Roblox Studio con DataStores

Roblox no guarda nada de un jugador entre sesiones a menos que un script de servidor lo haga. Esta guía construye un módulo PlayerData que carga, mantiene en memoria y guarda los datos de cada jugador con DataStoreService, y luego cubre las pruebas, los límites y cómo se pierden los datos guardados.

Actualizado el 12 de noviembre de 202620 min de lecturaEscrito por

La respuesta corta

Usa DataStoreService desde un Script de servidor: carga los datos de cada jugador con GetAsync cuando entra, guárdalos en una tabla mientras juega y guárdalos con UpdateAsync cada cierto tiempo, cuando sale (PlayerRemoving) y cuando el servidor se apaga (game:BindToClose). Envuelve cada llamada en pcall y reintenta los fallos unas cuantas veces.

  • Para probar en Studio, publica el place y activa File > Experience Settings > Security > Enable Studio Access to API Services, en un juego de prueba aparte: Studio usa los mismos datos que los servidores publicados.
  • Si los datos de un jugador no se cargan, nunca guardes a ese jugador. Guardar los valores por defecto sobrescribiría su progreso real.
  • Guarda una tabla por jugador bajo una sola clave como User_12345, cada cierto tiempo y no con cada cambio.
  • Para intercambios u objetos de pago, añade bloqueo de sesión para que dos servidores no puedan guardar al mismo jugador.
En esta página
  1. Activar el acceso en Studio
  2. Cómo funcionan los data stores
  3. GetAsync vs UpdateAsync
  4. 1. Módulo PlayerData
  5. Cómo funciona el módulo
  6. 2. Usar los datos
  7. 3. Avisar al jugador
  8. 4. Probar en Studio
  9. Por qué se pierden datos
  10. Bloqueo de sesión
  11. Límites
  12. Versiones y copias
  13. Errores comunes
  14. Con RoCode
  15. Preguntas frecuentes
  16. Fuentes y lecturas

Antes de empezar: activa el acceso desde Studio en una copia de prueba

Un juego que se ejecuta en Studio no puede acceder a los data stores hasta que lo permites. Permitirlo tiene una trampa que señala la documentación de Roblox: a partir de ahí Studio lee y escribe los mismos data stores que el juego publicado, así que una prueba que reinicia tus monedas en Studio también las reinicia en el juego publicado, y un error en el código de prueba puede dañar las claves de jugadores reales.

  1. Haz una copia de prueba. Guarda tu place en un archivo, abre la copia, elige File > Publish to Roblox As y haz clic en Create new game. No la añadas como place dentro de tu juego publicado: todos los places de un juego comparten los mismos data stores.
  2. En la copia de prueba, abre File > Experience Settings y ve a Security.
  3. Activa Enable Studio Access to API Services y haz clic en Save.

Las llamadas a data stores solo funcionan en Scripts de servidor; un LocalScript que lo intenta recibe un error, así que los clientes no pueden escribir datos guardados. Cuando un botón debe cambiarlos, el cliente se lo pide al servidor con un RemoteEvent y el servidor decide (consulta la guía de RemoteEvents, en inglés).

Cómo guardan los data stores los datos del jugador

IlustraciónLa prueba del paso 4 de la guía, acelerada: Play, Stop guarda la sesión en el data store, y Play otra vez la carga, así que el Output muestra 200.

Un data store es un conjunto con nombre de claves y valores en los servidores de Roblox, compartido por todos los servidores y todos los places de tu juego. DataStoreService:GetDataStore("PlayerData") devuelve uno.

Las buenas prácticas de Roblox se resumen en un data store para los datos del jugador, una clave por jugador, una tabla en cada clave. Construye la clave a partir del UserId del jugador, como User_12345, nunca a partir de su nombre, que puede cambiar. Un patrón fijo User_{UserId} también permite que el proceso automático de Roblox para el derecho al olvido encuentre los datos de un jugador si lo configuras.

Qué puede guardar un data store
Tipo¿Se guarda?Notas
Números, strings, booleanos, buffersSíLos strings tienen que ser UTF-8 válido. No guardes inf ni nan.
TablasSíSi todo lo que contienen también se puede guardar. Una tabla cuyas claves numéricas no empiezan en 1 (así que su longitud es 0) vuelve con esas claves convertidas en strings.
Instances, Vector3, CFrame, Color3NoEl guardado da error o guarda nil. Guarda el nombre de un objeto, o una posición como tres números.

Cada petición es una llamada web que puede fallar, tarda un tiempo y cuenta contra un presupuesto por minuto. Por eso los sistemas de guardado fiables leen una vez cuando el jugador entra, guardan los datos en una tabla del servidor mientras juega y los vuelven a escribir de vez en cuando.

GetAsync, SetAsync o UpdateAsync: cuál usar

Los métodos principales de un data store
MétodoQué haceÚsalo para
GetAsync(key)Lee el valor. El resultado se queda en caché en ese servidor durante 4 segundos.Cargar los datos de un jugador
SetAsync(key, value)Sobrescribe el valor sin leerlo. Una escritura.Una clave nueva, o un valor que no depende del anterior
UpdateAsync(key, callback)Lee el valor más reciente, se lo pasa a tu callback y escribe lo que devuelve. Una lectura y una escritura.Guardar los datos del jugador, y cualquier clave en la que pueda escribir más de un servidor
IncrementAsync(key, delta)Suma un número entero a un número entero guardado.Contadores
RemoveAsync(key)Borra la clave y devuelve el valor anterior. Las versiones anteriores todavía se pueden listar y leer.Borrar los datos de un jugador

SetAsync escribe a ciegas: si dos servidores guardan la misma clave casi a la vez, gana la última escritura, contenga lo que contenga. UpdateAsync lee primero el valor actual, y si otro servidor escribe entretanto, Roblox vuelve a ejecutar tu callback con el valor nuevo. Roblox lo recomienda siempre que una escritura depende del valor actual o varios servidores pueden escribir la clave, que es justo el caso de los datos del jugador. El callback tiene tres reglas:

  • No debe ceder (yield): nada de task.wait() ni de otras llamadas a data stores dentro de él.
  • Puede ejecutarse más de una vez, así que solo debe calcular el valor nuevo, nunca dar objetos ni disparar eventos.
  • Devolver nil cancela la escritura. El módulo lo usa para no sobrescribir datos guardados por una versión más nueva del juego.

Paso 1: crea el módulo PlayerData

Este ModuleScript es el único código que habla con el data store. Carga los datos de cada jugador cuando entra, los guarda en memoria, los guarda cada 180 segundos, cuando sale y cuando el servidor se apaga, y se niega a guardar a cualquiera cuyos datos no se cargaron.

  1. En el Explorer, pasa el ratón sobre ServerScriptService, haz clic en + e inserta un ModuleScript. Cámbiale el nombre a PlayerData y sustituye su contenido por el código de abajo.
  2. Un ModuleScript solo se ejecuta cuando un script lo requiere. Inserta un Script en ServerScriptService llamado Main con esta línea: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Los demás scripts de servidor lo requieren de la misma forma.
  3. Edita DEFAULTS y el tipo Data para que encajen con tu juego, manteniendo cada campo como número, string, booleano o tabla.
El Explorer después de los pasos 1 a 3
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript en ServerScriptService llamado PlayerData
-- PlayerData: carga los datos de cada jugador cuando entra, los guarda en memoria
-- y los guarda cada cierto tiempo, cuando sale y cuando el servidor se apaga.
-- Los demás scripts de servidor usan PlayerData.Get(player) para leerlos y cambiarlos.

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

local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- súbelo cuando cambie la forma de los datos, y añade un paso en migrate()
local AUTOSAVE_SECONDS = 180
-- En Studio una llamada fallida se rinde enseguida, así que probar sin acceso a data stores es rápido
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- se duplica después de cada fallo: 1, 2, 4

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

-- Con lo que empieza un jugador nuevo
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- false si la carga falló: los datos por defecto nunca deben sustituir el progreso real
}

-- Se llama dentro de cada pcall de abajo, así que un place que aún no está publicado
-- (sin acceso a data stores) sigue cargando a los jugadores con datos por defecto
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- guardados todavía en marcha, por clave
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- Se dispara con el jugador cuando sus datos están listos. Llama a PlayerData.Get(player) para obtener la tabla:
-- una tabla enviada por un BindableEvent llega como copia, así que cambiarla no cambiaría nada.
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) -- una copia nueva, para que los jugadores nunca compartan una tabla Inventory
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- Pone los datos guardados al día con el esquema actual. Devuelve nil si no se pueden usar con seguridad.
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 -- guardado por una versión más nueva del juego: nunca lo cargues ni lo sobrescribas aquí
	end

	-- Un paso por cada cambio de esquema, del más antiguo al más nuevo
	if version < 2 then
		-- Ejemplo: la versión 1 llamaba Gold a la moneda. Cópialo solo cuando falte Coins,
		-- para que los datos antiguos que ya tienen Coins pero no SchemaVersion conserven su valor.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Añade los campos creados desde la última vez que guardó este jugador, y sustituye los valores de tipo incorrecto
	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

-- Ejecuta una llamada a data store dentro de pcall. Si falla, espera y lo vuelve a intentar, duplicando la
-- espera cada vez y añadiendo un poco de azar para que los servidores no reintenten todos a la vez.
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 -- devolver nil cancela la escritura
			end
			-- Escribe la tabla actual completa, etiquetada con el UserId del jugador
			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()
		-- Empieza en un punto aleatorio del intervalo para que los servidores no guarden todos a la vez
		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

	-- Si este jugador acaba de salir de este servidor y ha vuelto, deja que termine primero el último guardado
	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 -- salió mientras cargaba: no ha cambiado nada, así que no hay nada que guardar
	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) -- una GUI puede leer esto y avisar al jugador
	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 -- detiene el bucle de autoguardado y hace que una segunda llamada no haga nada
	save(session)
end

-- La tabla de datos viva del jugador, o nil hasta que se haya cargado. Cámbiala solo desde scripts de servidor.
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True cuando los datos del jugador se cargaron y se guardarán. Compruébalo antes de vender nada.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Guarda ahora en lugar de esperar al temporizador, para momentos importantes como una compra.
-- Cede (yield), y devuelve true cuando el guardado se ha completado.
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) -- jugadores que entraron antes de que se requiriera este módulo por primera vez
end

game:BindToClose(function()
	-- El servidor da 30 segundos a estas funciones, así que guarda a todos a la vez
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Luego espera a cada guardado todavía en marcha, incluidos los que inició PlayerRemoving
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

Cuando el juego esté publicado, no cambies STORE_NAME ni el patrón de clave User_. Cambiar cualquiera de los dos apunta el módulo a claves vacías, y todos los jugadores vuelven a empezar con los valores por defecto.

Cómo mantiene seguros los datos el módulo

Valores por defecto y una versión de esquema

Un jugador nuevo recibe una copia nueva de DEFAULTS. Tiene que ser una copia: si todos los jugadores compartieran una sola tabla Inventory, un objeto añadido para uno aparecería para todos.

Cada tabla guardada lleva un SchemaVersion. Añadir un campo no necesita cambiar la versión, porque migrate rellena los campos que faltan con los valores por defecto. Renombrar o reestructurar sí: sube SCHEMA_VERSION y añade un paso, como el ejemplo que renombra Gold a Coins (en un juego nuevo, bórralo y empieza en 1). Los datos con una versión mayor que la del servidor vienen de una versión más nueva que todavía se está desplegando, así que los servidores antiguos no los tocan.

Una carga fallida nunca se guarda

Esta regla evita los borrados completos. Si todos los intentos de carga fallan, el jugador juega con datos por defecto, pero canSave es false, así que esos valores por defecto nunca sobrescriben su progreso real. El módulo también pone un atributo DataLoaded en false, que el paso 3 usa para avisarle. El ejemplo de referencia de Roblox maneja las cargas fallidas de la misma forma y lo recomienda antes que expulsar al jugador; si prefieres expulsarlo, llama a player:Kick() con un mensaje donde el módulo da el aviso.

Reintentos con espera creciente

withRetries envuelve cada llamada en pcall. Después de un fallo espera 1, luego 2 y luego 4 segundos, cada uno más hasta la mitad de ese tiempo al azar, y para después de cuatro intentos (uno en Studio, para que un place sin acceso a data stores arranque enseguida). El azar reparte los reintentos de muchos servidores después de una caída, y el límite mantiene la espera en unos 10 segundos, dentro de los 30 segundos que tiene un servidor para apagarse. Como cada guardado escribe la tabla viva completa mediante UpdateAsync, un reintento que termina tarde no puede volver a poner datos antiguos.

Cuándo guarda

CuándoPor qué
Cada 180 segundos mientras el jugador está en el servidorLimita lo que se pierde en un fallo del servidor. El primer guardado llega en un punto aleatorio del intervalo para que los servidores no guarden todos a la vez. El ejemplo de referencia de Roblox también usa 180 segundos.
Cuando el jugador sale (PlayerRemoving)El guardado final normal. Primero se quita la sesión, así que el autoguardado se detiene.
Cuando el servidor se apaga (game:BindToClose)Se guarda a la vez a todos los que siguen en el servidor, y la función espera a cada guardado en curso. Roblox le da 30 segundos.
Cuando se pide, con PlayerData.SaveNow(player)Después de algo que no se puede perder, como una compra.

Si un jugador vuelve a entrar en el mismo servidor mientras su guardado final todavía está en marcha, la nueva carga espera a que ese guardado termine, así que no puede leer el valor antiguo.

Paso 2: lee y cambia los datos desde otros scripts

Todos los scripts de servidor que requieren el módulo comparten las mismas tablas:

LlamadaQué hace
PlayerData.Get(player)La tabla de datos viva del jugador, o nil hasta que se haya cargado. Cambia los campos directamente, como data.Coins += 10, y el siguiente guardado lo recoge.
PlayerData.LoadedSe dispara con el jugador cuando sus datos están listos, también después de una carga fallida. Solo pasa el jugador, porque una tabla enviada por un BindableEvent llega como copia.
PlayerData.CanSave(player)false si la carga falló. Compruébalo antes de vender nada: una compra que no se puede guardar desaparece cuando el jugador sale.
PlayerData.SaveNow(player)Guarda al momento y devuelve true si funcionó. Cede (yield).

El módulo es el único lugar donde viven los datos guardados, y leaderstats es solo para mostrarlos: constrúyelo como en la guía de leaderboard, rellénalo desde PlayerData.Get(player) en un manejador de Loaded y actualiza los dos cuando cambie un valor. Nunca leas los valores guardados desde leaderstats, y nunca dejes que un segundo script guarde la misma clave.

Un script que requiere el módulo después de que los jugadores hayan entrado se pierde el Loaded de esos jugadores. Conecta el manejador y luego recorre también Players:GetPlayers() y atiende a cualquiera para quien PlayerData.Get(player) ya devuelva una tabla.

¿Sustituyes un script de guardado más antiguo, como el de la guía de leaderboard? Sus valores siguen en su propio data store y su propia clave, así que este módulo hace empezar a todos con los valores por defecto. Antes del lanzamiento, o apuntas STORE_NAME y el prefijo User_ a los antiguos (migrate trata los datos sin SchemaVersion como versión 1 y rellena los campos que faltan), o copias los valores antiguos, y luego quitas el script antiguo.

Los clientes nunca cambian estos datos directamente. Un botón de la tienda dispara un RemoteEvent; el servidor comprueba CanSave, compara el precio con las Coins del jugador, cambia la tabla y llama a SaveNow. La guía de tienda con GUI construye ese flujo de compra en el servidor.

Como ejemplo completo de añadir campos, la guía de simulador de clics añade PowerLevel y Rebirths a DEFAULTS y al tipo Data, y luego los cambia en la tabla que devuelve PlayerData.Get. migrate da los campos nuevos a los jugadores con guardados antiguos.

Paso 3: avisa al jugador cuando sus datos no se cargaron

Un jugador cuyos datos no se cargaron debería saber que esta sesión no se guardará, para que vuelva a entrar en lugar de jugar para nada. Este LocalScript vigila el atributo DataLoaded y muestra un aviso cuando es false.

LocalScript en StarterPlayerScripts llamado 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

-- El servidor pone DataLoaded una vez, después de intentar cargar los datos de este jugador
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

Paso 4: prueba el guardado en Studio

Hazlo en la copia de prueba, con el acceso desde Studio activado.

  1. Date algo que guardar. Debajo de la línea del require en Main, añade: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Pulsa Play. La ventana Output (en el menú Window o en la pestaña Script) muestra tu nombre y 100 (la primera vez), sin ningún aviso Could not load.
  3. Pulsa Stop. Terminar la prueba cierra el servidor, y el módulo te guarda antes de que cierre.
  4. Pulsa Play otra vez. El Output debería mostrar 200, 100 más que la vez anterior. Si vuelve a mostrar el mismo número, el guardado no se completó: lee los avisos que hay encima.
  5. Prueba el caso de fallo. Desactiva el acceso desde Studio y pulsa Play. Tras varios segundos de reintentos, el Output muestra Could not load User_... y 100, y aparece el aviso del paso 3. Pulsa Stop, vuelve a activar el acceso y pulsa Play: el Output muestra 300, tus 200 guardados más 100, porque la sesión fallida nunca se guardó encima de tus datos.
  6. Quita la línea de prueba de Main.

Por qué se pierden los datos del jugador

Estas son las formas habituales en que un sistema de guardado pierde progreso. El módulo resuelve en código las cuatro primeras filas y la del esquema; las demás dependen de lo que guardas y de cómo lo usas, y la última necesita bloqueo de sesión.

Qué pasaResultadoPrevención
Una carga falla y el script guarda igualmenteLos valores por defecto sobrescriben el progreso real: un borrado completoNunca guardes a un jugador cuya carga falló
Guardar solo en PlayerRemovingUn fallo o un apagado del servidor se salta el guardadoAutoguardado, más un BindToClose que espera a sus guardados
Sin pcall o sin reintentosUna sola petición fallida detiene el script o pierde el guardadopcall con unos cuantos reintentos espaciados
Guardar con cada cambioLas peticiones se acumulan; cuando una cola llega a 30, las nuevas se descartanGuarda los datos en memoria y guarda cada cierto tiempo
Guardar algo que un data store no puede contenerEl guardado da error, o el valor vuelve como nilGuarda números, strings, booleanos y tablas de ellos
Cambiar la forma de los datos sin migraciónLos guardados antiguos se cargan en los campos equivocadosUna versión de esquema y un paso de migración
Dos scripts que guardan la misma claveCada guardado sobrescribe los campos del otroUn solo módulo es el dueño de la clave
Dos servidores con el mismo jugadorEl servidor con datos más antiguos guarda el último y sobrescribe el progreso más nuevoBloqueo de sesión

Bloqueo de sesión, "lock lost" y ProfileStore

Un jugador está conectado a un servidor cada vez, pero el guardado final del servidor anterior puede seguir en marcha cuando entra en uno nuevo: un reintento lento, un teletransporte o una reentrada rápida. Si el servidor nuevo carga primero, tiene datos más antiguos, y gana el servidor que guarde el último. La documentación de Roblox señala que en juegos con intercambios, este hueco es una fuente común de duplicación de objetos.

El bloqueo de sesión lo cierra. Cuando un servidor carga la clave de un jugador, escribe su propio ID de bloqueo en los metadatos de la clave en la misma llamada a UpdateAsync. Cualquier otro servidor que encuentre un bloqueo sin caducar que no puso él no cargará ni guardará la clave. El dueño renueva el bloqueo con cada autoguardado y lo quita en el guardado final; si deja de renovarlo, el bloqueo caduca y otro servidor puede quedárselo.

Qué significa "lock lost"

En un sistema con bloqueo de sesión, un servidor ha perdido el bloqueo cuando otro servidor es ahora el dueño de la clave del jugador, porque el bloqueo caducó o se lo quitaron. Su copia puede estar desactualizada, así que debe dejar de guardar a ese jugador; una respuesta habitual es expulsarlo con un mensaje para que se vuelva a conectar. Si viste "lock lost" como jugador, viene del propio sistema de guardado de ese juego, y solo sus desarrolladores pueden explicarlo.

¿Lo necesitas?

El módulo de esta guía no bloquea sesiones. Sin bloqueo, el peor caso realista es que un jugador pierda lo que ganó en el servidor anterior desde su último guardado correcto, en una carrera poco frecuente. Añade bloqueo cuando la duplicación o la pérdida le costaría algo real a los jugadores: intercambios, developer products, objetos raros o teletransportes frecuentes.

OpciónQué esConviene saber
El módulo de esta guíaCarga, memoria, reintentos, autoguardado, guardados al apagar y versiones de esquema, sin bloqueoLo bastante corto para leerlo entero y cambiarlo
El ejemplo de datos del jugador y compras de RobloxCódigo de referencia de Roblox con bloqueo de sesión, reintentos procesados en orden por clave y manejo de recibos de compraRoblox dice que no se ha probado a lo largo del tiempo en un juego popular y que no debería usarse tal cual sin pruebas exhaustivas
ProfileStoreUn módulo gratuito y de código abierto de la comunidad, sucesor de ProfileService, construido en torno al bloqueo de sesión y el autoguardadoNo lo hace Roblox. Pasar a él un juego existente significa migrar los datos que ya guardaste

Para cualquier módulo de terceros, Roblox aconseja comprobar quién es el dueño, si se mantiene y cómo llegarías a tus datos sin él. La misma documentación llama a DataStore2 una biblioteca antigua que los juegos nuevos no deberían usar.

Límites de los data stores

Estos son los límites de la documentación de Roblox del 30 de septiembre de 2026. Roblox los revisa, así que consulta la página de códigos de error y límites (en inglés) antes de diseñar en torno a un número exacto.

Límites de peticiones por defecto de cada servidor, por minuto
Tipo de peticiónData stores estándarOrdered data stores
Lectura: GetAsync, la lectura de UpdateAsync60 + 40 × jugadores60 + 40 × jugadores
Escritura: SetAsync, IncrementAsync, la escritura de UpdateAsync60 + 40 × jugadores30 + 5 × jugadores
Listado: ListKeysAsync, o GetSortedAsync para los ordered stores5 + 2 × jugadores5 + 2 × jugadores
Borrado: RemoveAsync60 + 40 × jugadores30 + 5 × jugadores

Con 20 jugadores, un servidor puede hacer 860 escrituras estándar por minuto; el autoguardado de este módulo usa unas 7, más una por cada jugador que sale. Guardar con cada moneda recogida es lo que agota el presupuesto. Un segundo presupuesto cubre el juego entero y se comparte con Open Cloud: 300 lecturas por minuto más 40 por jugador conectado, y 300 escrituras más 20 por jugador.

Límites de tamaño y de volumen
LímiteValor
Nombre del data store, nombre de la clave, scope50 caracteres cada uno
Valor guardado en una clave4,194,304 caracteres, medidos como JSON
Lecturas de una clave, entre todos los servidores25 MB por minuto
Escrituras en una clave, entre todos los servidores4 MB por minuto, cada petición redondeada al KB siguiente
Peticiones en espera30 por cola; a partir de ahí, las peticiones fallan con los errores 301 a 306
Almacenamiento para todo el juego500 MB más 1 MB por usuario histórico

Mide los datos de un jugador con #HttpService:JSONEncode(data), y mira el presupuesto que le queda a un servidor en marcha con DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite). Las llamadas a GetAsync respondidas desde la caché de 4 segundos no cuentan. El modo Run de Studio tiene sus propios límites, quizá más bajos, así que Roblox sugiere Team Create para probar los límites de peticiones.

Versiones y copias de seguridad

Los data stores estándar guardan el historial por ti. La primera escritura en una clave en cada hora UTC se conserva como versión, y las escrituras posteriores en esa hora se sobrescriben entre sí. Una versión antigua caduca 30 días después de que una escritura más nueva la sustituya; la más reciente nunca caduca. Los ordered data stores no guardan versiones.

Para revertir a un jugador, abre Data Stores Manager (Creations, tu juego, Configure > Data Stores Manager), selecciona su clave, elige una versión anterior y haz clic en Revert, lo que necesita permiso de edición. Hazlo mientras el jugador está desconectado, o el servidor que tiene su sesión guardará su copia encima de la reversión. Desde un script de servidor, ListVersionsAsync y GetVersionAsync encuentran y leen una versión antigua, que luego vuelves a escribir como valor actual.

Antes de publicar una actualización que cambia cómo se guardan los datos, Roblox recomienda una instantánea con la API Snapshot Data Stores de Open Cloud (una al día por juego). Sin ella, un guardado con errores a las 3:30 UTC sobrescribe todo lo escrito en esa clave desde las 3:00, porque cae en la misma versión horaria.

Errores comunes y soluciones

Los errores de data store aparecen en la ventana Output de Studio, y el módulo imprime un aviso con el texto de error de Roblox en cada intento fallido. La guía de errores de scripts explica cómo leer el Output en general.

StudioAccessToApisNotAllowed (error 403)

"Can't write to DataStore from Studio because API access is not enabled." Publica el place y activa Enable Studio Access to API Services en File > Experience Settings > Security, en la copia de prueba.

DataStore request was added to queue

El servidor envía peticiones más rápido de lo que permite su presupuesto, o escribe la misma clave demasiado a menudo, normalmente por guardar con cada cambio o dentro de un bucle. Cuando una cola llega a 30, las peticiones nuevas fallan con los errores 301 a 306. Guarda los datos en memoria y guarda cada cierto tiempo.

CantStoreValue (error 104), o un campo vuelve como nil

La tabla contiene algo que un data store no puede guardar, como una Instance, un Vector3 o un Color3. Guarda un nombre, un ID o números simples en su lugar y reconstruye el objeto al cargar.

ValueTooLarge (error 105)

Una clave contiene más de 4,194,304 caracteres de JSON. Mídelo con #HttpService:JSONEncode(data), quita lo que puedas reconstruir o reparte los datos en unas pocas claves fijas.

No hay errores, pero los datos no se guardan

Busca el aviso Could not load del módulo: después de una carga fallida se niega a guardar, a propósito. Si no, probablemente el valor se cambió en un LocalScript, lo que nunca llega al servidor, u otro script guarda la misma clave.

Los datos se reinician cada vez que vuelvo a entrar

La clave cambia entre sesiones (construida con player.Name, o se editó STORE_NAME), la carga falla y ves los valores por defecto, o nada requiere el módulo y nunca se ejecuta. Revisa el Output y que Main requiera PlayerData.

Constrúyelo con RoCode

Si prefieres no conectarlo todo a mano, RoCode puede construirlo dentro del place que tienes abierto. Es un agente de IA independiente, no lo hace Roblox, que trabaja mediante un plugin de Roblox Studio: escribe Luau que usa DataStoreService como cualquier script y crea los scripts en tu Explorer. Nunca llama él mismo a tus data stores, pero con el plugin 3.9 o posterior puede pulsar Play para una prueba corta, donde tus scripts se ejecutan como en cualquier prueba.

Tú escribes

Añade guardado a mi juego: guarda Coins, Level e Inventory en un módulo PlayerData con autoguardado y guardado al apagar el servidor, y muestra Coins en las leaderstats que ya tengo.

RoCode hace
  • Puede buscar código de leaderstats y DataStore que ya exista con Search Scripts y Read Script, para ampliar lo que tienes en lugar de añadir un segundo script de guardado. En un place grande, nombra el script o la carpeta en tu mensaje.
  • Crea el ModuleScript y el Script que lo requiere con Create Script, o cambia los que ya tienes con Edit Script
  • Ejecuta Check Script en cada script que escribió: una comprobación de compilación dentro de Studio con una lista corta de avisos, no una comprobación de tipos ni una prueba de juego
  • Envía sus cambios en lotes, y cada lote es un punto de deshacer en Studio

Studio Access to API Services lo sigues activando tú en tu copia de prueba: RoCode no puede cambiar ese ajuste. Con el plugin 3.9 o posterior su prueba corta lee los errores, y con el plugin 3.9.11 o posterior puede controlar un personaje de prueba para comprobar que el juego funciona, pero solo comprueba lo que eligió probar, así que juega tú para comprobar que Coins, Level e Inventory se guardan y se cargan. Si un guardado falla en tu prueba, Check Output puede leer las líneas Server de la prueba que hiciste. El guardado suele llegar cuando el bucle principal ya funciona; hacer un juego de Roblox con IA, un sistema cada vez explica ese orden. Cómo se conecta RoCode a Studio.

Preguntas frecuentes

¿Cómo activo DataStore en Roblox Studio?

Publica el place, abre File > Experience Settings > Security, activa Enable Studio Access to API Services y haz clic en Save. Hazlo en un juego de prueba aparte, porque a partir de ahí Studio usa los mismos data stores que los servidores publicados de ese juego.

¿Roblox guarda los datos del jugador automáticamente?

No. Nada de un jugador dura más allá de la sesión a menos que un script de servidor lo guarde con DataStoreService, y eso incluye leaderstats.

¿Debería usar ProfileStore o DataStoreService directamente?

ProfileStore también está construido sobre data stores, así que la pregunta es si quieres que el bloqueo de sesión lo escriba y lo mantenga otro. Para intercambios, objetos de pago o teletransportes frecuentes, el bloqueo merece la pena, de una biblioteca o del ejemplo de referencia de Roblox. Para un juego más pequeño, un módulo como este es más fácil de leer y cambiar.

¿Cómo reinicio o borro los datos de un jugador?

En Data Stores Manager, busca la clave y elige Mark for Deletion, que puedes deshacer durante un periodo de espera, o llama a RemoveAsync sobre la clave desde un script de servidor. Hazlo mientras el jugador está desconectado, o el siguiente guardado de su servidor volverá a escribir los datos. En la copia de prueba, cambiar STORE_NAME hace empezar de cero a todos; nunca lo hagas en un juego publicado.

Fuentes y lecturas

Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 12 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.