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
- Activar el acceso en Studio
- Cómo funcionan los data stores
- GetAsync vs UpdateAsync
- 1. Módulo PlayerData
- Cómo funciona el módulo
- 2. Usar los datos
- 3. Avisar al jugador
- 4. Probar en Studio
- Por qué se pierden datos
- Bloqueo de sesión
- Límites
- Versiones y copias
- Errores comunes
- Con RoCode
- Preguntas frecuentes
- 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.
- 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.
- En la copia de prueba, abre File > Experience Settings y ve a Security.
- 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
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.
| Tipo | ¿Se guarda? | Notas |
|---|---|---|
| Números, strings, booleanos, buffers | Sí | Los strings tienen que ser UTF-8 válido. No guardes inf ni nan. |
| Tablas | Sí | 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, Color3 | No | El 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
| Método | Qué 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
nilcancela 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.
- En el Explorer, pasa el ratón sobre ServerScriptService, haz clic en + e inserta un ModuleScript. Cámbiale el nombre a
PlayerDatay sustituye su contenido por el código de abajo. - Un ModuleScript solo se ejecuta cuando un script lo requiere. Inserta un Script en ServerScriptService llamado
Maincon esta línea:local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Los demás scripts de servidor lo requieren de la misma forma. - Edita
DEFAULTSy el tipoDatapara que encajen con tu juego, manteniendo cada campo como número, string, booleano o tabla.
ServerScriptService
PlayerData ModuleScript new
Main Script new
StarterPlayer
StarterPlayerScripts
DataWarning LocalScript new
-- 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ándo | Por qué |
|---|---|
| Cada 180 segundos mientras el jugador está en el servidor | Limita 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:
| Llamada | Qué 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.Loaded | Se 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.
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.
- 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) - 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. - Pulsa Stop. Terminar la prueba cierra el servidor, y el módulo te guarda antes de que cierre.
- 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.
- 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. - 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é pasa | Resultado | Prevención |
|---|---|---|
| Una carga falla y el script guarda igualmente | Los valores por defecto sobrescriben el progreso real: un borrado completo | Nunca guardes a un jugador cuya carga falló |
Guardar solo en PlayerRemoving | Un fallo o un apagado del servidor se salta el guardado | Autoguardado, más un BindToClose que espera a sus guardados |
Sin pcall o sin reintentos | Una sola petición fallida detiene el script o pierde el guardado | pcall con unos cuantos reintentos espaciados |
| Guardar con cada cambio | Las peticiones se acumulan; cuando una cola llega a 30, las nuevas se descartan | Guarda los datos en memoria y guarda cada cierto tiempo |
| Guardar algo que un data store no puede contener | El guardado da error, o el valor vuelve como nil | Guarda números, strings, booleanos y tablas de ellos |
| Cambiar la forma de los datos sin migración | Los guardados antiguos se cargan en los campos equivocados | Una versión de esquema y un paso de migración |
| Dos scripts que guardan la misma clave | Cada guardado sobrescribe los campos del otro | Un solo módulo es el dueño de la clave |
| Dos servidores con el mismo jugador | El servidor con datos más antiguos guarda el último y sobrescribe el progreso más nuevo | Bloqueo 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ón | Qué es | Conviene saber |
|---|---|---|
| El módulo de esta guía | Carga, memoria, reintentos, autoguardado, guardados al apagar y versiones de esquema, sin bloqueo | Lo bastante corto para leerlo entero y cambiarlo |
| El ejemplo de datos del jugador y compras de Roblox | Código de referencia de Roblox con bloqueo de sesión, reintentos procesados en orden por clave y manejo de recibos de compra | Roblox 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 |
| ProfileStore | Un módulo gratuito y de código abierto de la comunidad, sucesor de ProfileService, construido en torno al bloqueo de sesión y el autoguardado | No 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.
| Tipo de petición | Data stores estándar | Ordered data stores |
|---|---|---|
Lectura: GetAsync, la lectura de UpdateAsync | 60 + 40 × jugadores | 60 + 40 × jugadores |
Escritura: SetAsync, IncrementAsync, la escritura de UpdateAsync | 60 + 40 × jugadores | 30 + 5 × jugadores |
Listado: ListKeysAsync, o GetSortedAsync para los ordered stores | 5 + 2 × jugadores | 5 + 2 × jugadores |
Borrado: RemoveAsync | 60 + 40 × jugadores | 30 + 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ímite | Valor |
|---|---|
| Nombre del data store, nombre de la clave, scope | 50 caracteres cada uno |
| Valor guardado en una clave | 4,194,304 caracteres, medidos como JSON |
| Lecturas de una clave, entre todos los servidores | 25 MB por minuto |
| Escrituras en una clave, entre todos los servidores | 4 MB por minuto, cada petición redondeada al KB siguiente |
| Peticiones en espera | 30 por cola; a partir de ahí, las peticiones fallan con los errores 301 a 306 |
| Almacenamiento para todo el juego | 500 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.
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.
- 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
- Roblox Creator Docs: Data stores (en inglés). acceso desde Studio, GetAsync, SetAsync, UpdateAsync, set frente a update
- Roblox Creator Docs: Best practices for data stores (en inglés). una clave por jugador, datos en memoria, reintentos con espera creciente, módulos de terceros
- Roblox Creator Docs: Data store error codes and limits (en inglés). códigos de error, límites de peticiones por servidor y por juego, límites de tamaño, volumen y almacenamiento
- Roblox Creator Docs: Versioning, listing and caching (en inglés). versiones por hora, instantáneas, la caché de 4 segundos, qué se puede guardar
- Roblox Creator Docs: Implement player data and purchasing systems (en inglés). el ejemplo de referencia, bloqueo de sesión, cargas fallidas, el autoguardado de 180 segundos
- Roblox Creator Docs: Data Stores Manager (en inglés). ver claves, revertir versiones, borrar datos
- Roblox Engine API: DataModel:BindToClose (en inglés). la ventana de 30 segundos al apagar
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.