Salva i dati

I giochi spesso hanno bisogno di archiviare dati persistenti tra le sessioni, come il livello di un giocatore, i punti esperienza, il denaro, gli oggetti inventario, la posizione e altro ancora.

Questo tutorial mostra come creare un deposito di dati di base **** , salvare i dati del giocatore e leggere i dati di nuovo in una sessione di gioco.

Abilita l'accesso a Studio

Per impostazione predefinita, i giochi testati in Studio non possono accedere ai depositi di dati, quindi devi prima abilitarli:

1. Pubblica l'esperienza.

2. Scegli File e Impostazioni di gioco .

3. Nella sezione Sicurezza , attiva Abilita l'accesso di Studio ai servizi API e clicca Salva .

Crea un magazzino di dati

I depositi di dati richiedono un nome univoco nome .Questo esempio crea un archivio dati chiamato PlayerGold che salva l'oro di ogni giocatore in uno storage persistente:

1. Crea un Script all'interno di ServerScriptService chiamato GoldManager .

   

2. Gli archivi di dati sono gestiti da DataStoreService, quindi ottieni il servizio:

   local DataStoreService = game:GetService("DataStoreService")

3. Chiama DataStoreService:GetDataStore() con la stringa "PlayerGold".Questo metodo accede al deposito dati PlayerGold se esiste già.Se non esiste, il metodo crea un nuovo archivio dati e lo nomina PlayerGold .

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

Salva i dati

Un archivio dati è essenzialmente un dizionario, come una tabella Luau.Ogni valore nel data store è indicizzato da una chiave unica , che potrebbe essere l'unica del giocatore o semplicemente una stringa nominata per una promozione di gioco.

Per salvare i dati del giocatore nel data store:

1. Crea una variabile chiamata playerUserID per la chiave del deposito di dati. Quindi, usa playerGold per memorizzare la quantità iniziale d'oro di un giocatore.

   local DataStoreService = game:GetService("DataStoreService")
   
   local goldStore = DataStoreService:GetDataStore("PlayerGold")
   
   -- Chiave e valore del deposito di dati
   local playerUserID = 505306092
   local playerGold = 250

2. Per salvare i dati nel deposito di dati PlayerGold, chiama SetAsync all'interno di una chiamata protetta, passando le variabili chiave e valore precedentemente create.

   local DataStoreService = game:GetService("DataStoreService")
   
   local goldStore = DataStoreService:GetDataStore("PlayerGold")
   
   -- Chiave e valore del deposito di dati
   local playerUserID = 505306092
   local playerGold = 250
   
   -- Imposta la chiave del magazzino dati
   local success, error = pcall(function()
       goldStore:SetAsync(playerUserID, playerGold)
   end)
   if not success then
       warn(error)
   end

Le funzioni come SetAsync() sono chiamate di rete che possono occasionalmente fallire.Come mostrato sopra, pcall() viene utilizzato per rilevare e gestire quando si verificano tali errori.

Nella sua forma più basilare, pcall() accetta una funzione e restituisce due valori:

• Lo stato, che è true se la funzione viene eseguita senza errori, o false altrimenti.
• Il valore di ritorno della funzione o un messaggio di errore.

L'esempio sopra controlla lo stato sulla linea 13. Se SetAsync() fallisce per qualsiasi motivo, l'esempio visualizza l'errore nella finestra Output.

Leggi i dati

Per leggere i dati da un archivio dati, chiama GetAsync() con il nome chiave desiderato.

local DataStoreService = game:GetService("DataStoreService")

local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Chiave e valore del deposito di dati
local playerUserID = 505306092
local playerGold = 250

-- Imposta la chiave del magazzino dati
local setSuccess, errorMessage = pcall(function()
	goldStore:SetAsync(playerUserID, playerGold)
end)
if not setSuccess then
	warn(errorMessage)
end

-- Leggi la chiave del data store
local getSuccess, currentGold = pcall(function()
	return goldStore:GetAsync(playerUserID)
end)
if getSuccess then
	print(currentGold)
end

Per testare lo script, clicca su Esegui e nota il valore currentGold stampato nella finestra Output .Nota che potrebbero volerci un paio di secondi, poiché le funzioni devono connettersi ai server del data store.

Leggere e salvare automaticamente

Lo script precedente funziona, ma ha un problema fondamentale: include valori hard-coded per playerUserID e playerGold, quindi non supporta più di un giocatore con diverse quantità d'oro.Una soluzione più realistica legge il valore dell'oro quando il giocatore si connette all'esperienza e lo salva quando il giocatore se ne va.Questo approccio significa connettere le chiamate al deposito di dati a eventi dal servizio >.

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

local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Aggiungi i valori d'oro per ogni giocatore a una tabella locale per evitare di colpire i dati
-- memorizza ripetutamente.
local playerGold = {}

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

local function onPlayerAdded(player)
    -- Leggi la chiave del data store
    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

    -- Test incremento dell'oro
    incrementGold(player, 5)
end

local function onPlayerRemoving(player)
    -- Imposta la chiave del magazzino dati
    local success, err = pcall(function()
        goldStore:SetAsync(player.UserId, playerGold[player.UserId])
    end)
    if not success then
        warn(err)
    end
    -- Pulisci l'ingresso in modo che la tabella non cresca per la durata della vita del server
    playerGold[player.UserId] = nil
end

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

Leggere e salvare la posizione del personaggio

Per salvare la posizione del giocatore, lavori con il Character piuttosto che con il Player, ma il principio è simile.Questa volta, crea un Script dentro ServerScriptService chiamato 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)

    -- Carica la posizione sul personaggio durante l'aggiunta
    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

        -- Gestire il respawn del giocatore dopo la morte
        local humanoid = character:FindFirstChildOfClass("Humanoid")
        humanoid.Died:Connect(function()
            local spawnLocation = Workspace:FindFirstChild("SpawnLocation")
            character:PivotTo(spawnLocation.CFrame)
        end)
    end)

    -- Salva posizione dopo la rimozione del personaggio
    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)

Questo script aggiunge un nuovo deposito di dati, playerPositionStore .Poiché i depositi di dati memorizzano solo tipi di base piuttosto che oggetti, devi memorizzare le coordinate X, Y e Z come numeri individuali piuttosto che un singolo valore Vector3 o CFrame.Mentre testi la tua esperienza, muovi il tuo personaggio in giro.Nota come il tuo personaggio ritorna alla stessa posizione la prossima volta che provi la tua esperienza.

Progetto di esempio

Ora che hai capito l'uso del deposito di dati di base, mettilo alla prova nel gioco di esempio Gold Rush.Puoi anche modificare il gioco in Studio e esplorare lo script migliorato GoldManager , che visualizza l'oro come parte dell'interfaccia utente e include il salvataggio automatico.