Guardar datos

A menudo es necesario que los juegos almacenen datos persistentes entre sesiones, como el nivel de un jugador, puntos de experiencia, dinero, artículos de inventario, ubicación y más.

Este tutorial muestra cómo crear un almacén de datos básico , guardar los datos del jugador y leer los datos de vuelta en una sesión de juego.

Habilitar el acceso a Studio

Por defecto, los juegos probados en Studio no pueden acceder a los almacenes de datos, por lo que debe habilitarlos primero:

1. Publicar la experiencia.

2. Elija Archivo y Configuración del juego .

3. En la sección Seguridad , activa Habilitar acceso de Studio a servicios de API y haz clic en Guardar .

Cree un almacén de datos

Las tiendas de datos requieren un nombre único nombre .Este ejemplo crea un almacén de datos llamado PlayerGold que guarda el oro de cada jugador en almacenamiento persistente:

1. Crea un Script dentro de ServerScriptService llamado GoldManager .

   

2. Los almacenes de datos son administrados por DataStoreService, así que obtenga el servicio:

   local DataStoreService = game:GetService("DataStoreService")

3. Llamar DataStoreService:GetDataStore() con la cadena "PlayerGold".Este método accede al almacén de datos PlayerGold si ya existe.Si no existe, el método crea un nuevo almacén de datos y lo nombra PlayerGold .

   local DataStoreService = game:GetService("DataStoreService")
   
   local goldStore = DataStoreService:GetDataStore("PlayerGold")

Guardar datos

Un almacén de datos es esencialmente un diccionario, como una tabla de Luau.Cada valor en el almacén de datos está indexado por una clave única , que podría ser la clave única del jugador o simplemente una cadena nominal para una promoción de juegos.

Para guardar los datos del jugador en la tienda de datos:

1. Crea una variable llamada playerUserID para la clave del almacén de datos. Luego, utiliza playerGold para almacenar la cantidad inicial de oro de un jugador.

   local DataStoreService = game:GetService("DataStoreService")
   
   local goldStore = DataStoreService:GetDataStore("PlayerGold")
   
   -- Clave y valor del almacén de datos
   local playerUserID = 505306092
   local playerGold = 250

2. Para guardar datos en el almacén de datos PlayerGold, llame a SetAsync dentro de una llamada protegida, pasando las variables clave y de valor creadas previamente

   local DataStoreService = game:GetService("DataStoreService")
   
   local goldStore = DataStoreService:GetDataStore("PlayerGold")
   
   -- Clave y valor del almacén de datos
   local playerUserID = 505306092
   local playerGold = 250
   
   -- Establecer la clave del almacén de datos
   local success, error = pcall(function()
       goldStore:SetAsync(playerUserID, playerGold)
   end)
   if not success then
       warn(error)
   end

Las funciones como SetAsync() son llamadas de red que pueden fallar ocasionalmente.Como se muestra arriba, pcall() se usa para detectar y manejar cuando ocurren tales fallos.

En su forma más básica, pcall() acepta una función y devuelve dos valores:

• El estado, que es true si la función se ejecutó sin errores, o false de lo contrario.
• El valor de retorno de la función o un mensaje de error.

La muestra anterior comprueba el estado en la línea 13. Si SetAsync() falla por cualquier razón, la muestra muestra el error en la ventana Salida.

Leer datos

Para leer datos de un almacén de datos, llame a GetAsync() con el nombre de clave deseado.

local DataStoreService = game:GetService("DataStoreService")

local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Clave y valor del almacén de datos
local playerUserID = 505306092
local playerGold = 250

-- Establecer la clave del almacén de datos
local setSuccess, errorMessage = pcall(function()
	goldStore:SetAsync(playerUserID, playerGold)
end)
if not setSuccess then
	warn(errorMessage)
end

-- Lee la clave del almacén de datos
local getSuccess, currentGold = pcall(function()
	return goldStore:GetAsync(playerUserID)
end)
if getSuccess then
	print(currentGold)
end

Para probar el script, haz clic en Ejecutar y observa el valor currentGold impreso en la ventana Salida .Tenga en cuenta que puede tardar un par de segundos, ya que las funciones deben conectarse a los servidores de almacenamiento de datos.

Leer y guardar automáticamente

El guión anterior funciona, pero tiene un problema fundamental: incluye valores codificados en duro para playerUserID y playerGold, por lo que no soporta a múltiples jugadores con diferentes cantidades de oro.Una solución más realista lee el valor del oro cuando el jugador se conecta a la experiencia y luego lo guarda cuando el jugador se va.Este enfoque significa conectar las llamadas al almacén de datos a eventos del servicio .

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

local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Agrega valores de oro para cada jugador a una tabla local para evitar golpear los datos
-- almacenar repetidamente
local playerGold = {}

local function incrementGold(player, amount)
    playerGold[player.UserId] += amount
end

local function onPlayerAdded(player)
    -- Lee la clave del almacén de datos
    local success, storedGold = pcall(function()
        return goldStore:GetAsync(player.UserId)
    end)
    if success then
        local currentGold
        if storedGold then
            currentGold = storedGold
        else
            currentGold = 0
        end
        playerGold[player.UserId] = currentGold
        print(currentGold)
    end

    -- Prueba incrementando oro
    incrementGold(player, 5)
end

local function onPlayerRemoving(player)
    -- Establecer la clave del almacén de datos
    local success, err = pcall(function()
        goldStore:SetAsync(player.UserId, playerGold[player.UserId])
    end)
    if not success then
        warn(err)
    end
    -- Limpie la entrada para que la tabla no crezca durante la vida útil del servidor
    playerGold[player.UserId] = nil
end

Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

Leer y guardar la posición del personaje

Para guardar la posición del jugador, trabajas con el Character en lugar del Player, pero el principio es similar.Esta vez, cree un Script dentro de ServerScriptService llamado PositionManager :

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

local playerPositionStore = DataStoreService:GetDataStore("PlayerPositionStore")

local function positionHandler(player)

    -- Carga la posición en la adición de personaje
    player.CharacterAdded:Connect(function(character)
        local success, coords = pcall(function()
            return playerPositionStore:GetAsync(player.UserId)
        end)
        local position = Vector3.new(coords[1], coords[2], coords[3])
        if success and position then
            character:PivotTo(CFrame.new(position))
            print("Loaded player position!")
        else
            warn("Failed to load position for player " .. player.Name .. ". Placing in default position.")
        end

        -- Manija el reaparecimiento del jugador al morir
        local humanoid = character:FindFirstChildOfClass("Humanoid")
        humanoid.Died:Connect(function()
            local spawnLocation = Workspace:FindFirstChild("SpawnLocation")
            character:PivotTo(spawnLocation.CFrame)
        end)
    end)

    -- Guardar posición al eliminar caracteres
    player.CharacterRemoving:Connect(function(character)
        local position = character:GetPivot().Position
        local success, err = pcall(function()
            playerPositionStore:SetAsync(player.UserId, {position.X, position.Y, position.Z})
            print("Saved player position!")
        end)
        if not success then
            warn("Failed to save position for player " .. player.Name .. ": " .. err)
        end
    end)
end

Players.PlayerAdded:Connect(positionHandler)

Este script agrega un nuevo almacén de datos, playerPositionStore .Debido a que los almacenes de datos solo almacenan tipos básicos en lugar de objetos, debe almacenar las coordenadas X, Y y Z como números individuales en lugar de un solo valor Vector3 o CFrame.Mientras pruebas tu experiencia, mueve a tu personaje.Nota cómo tu personaje regresa a la misma posición la próxima vez que pruebes tu experiencia.

Proyecto de ejemplo

Ahora que entiendes el uso básico del almacén de datos, pruebalo en el juego de muestra Gold Rush.También puedes editar el juego en Studio y explorar el guión mejorado de Gestor de oro , que muestra oro como parte de la interfaz de usuario y que incluye el guardado automático.