Salva i dati dei giocatori con i data store standard

I data store sono un servizio che puoi utilizzare per salvare e caricare dati persistenti dei giocatori attraverso diverse sessioni di gioco. Memorizzano informazioni importanti, come i progressi o l'inventario di un giocatore, e permettono di recuperarle per il giocatore la prossima volta che si unisce al tuo gioco. Senza i data store, un giocatore perderebbe tutto il proprio progresso ogni volta che esce dal gioco.

Ci sono due tipi di data store: standard e ordinati. Questo tutorial utilizza data store standard, che memorizzano dati come numeri, stringhe e tabelle che non devono essere classificati o ordinati.

Utilizzando il file tutorial dei data store Gold Rush - Inizio .rbxl come punto di partenza e il file tutorial dei data store Gold Rush - Completo .rbxl come riferimento, questo tutorial ti fornisce la base necessaria per salvare i progressi dei giocatori e creare giochi più coerenti, inclusi suggerimenti su:

• Salvare e caricare la quantità di oro che un giocatore ha raccolto.
• Aggiornare l'interfaccia utente per visualizzare l'inventario dell'oro del giocatore.
• Salvare automaticamente l'inventario dell'oro del giocatore ogni 30 secondi.
• Salvare la posizione del giocatore quando lascia il gioco.
• Ripristinare la posizione del giocatore quando si unisce nuovamente al gioco.

Alla fine di questo tutorial, dovresti avere due script con data store sotto ServerScriptService:

1. Uno script GoldManager aggiornato che traccia, carica e salva automaticamente l'oro del giocatore.
2. Uno script PositionManager aggiornato che salva la posizione del giocatore quando lascia il gioco e ripristina la sua posizione quando ritorna nel gioco.

Abilita l'accesso di Studio ai servizi API

I data store non sono memorizzati localmente sul tuo dispositivo, quindi il tuo gioco si basa sulla comunicazione server a server con il backend di Roblox per utilizzarli. Per impostazione predefinita, Studio limita questa comunicazione per prevenire abusi o usi accidentali. L'accesso ai servizi API in Studio è disabilitato fino a quando non lo attivi esplicitamente per assicurarti che solo i giochi fidati possano leggere e scrivere nei server backend di Roblox.

Per abilitare l'accesso di Studio ai servizi API in modo da poter utilizzare i data store:

1. Apri il file Gold Rush data store tutorial - Start .rbxl in Studio e crea una copia locale.
2. Pubblica il tuo gioco.
3. Tornando in Studio, vai su File ⟩ Impostazioni esperienza ⟩ Sicurezza.
4. Attiva Abilita accesso di Studio ai servizi API.
5. Salva le tue modifiche.

Crea un data store standard

Quando crei un data store, dovresti sempre chiamare DataStoreService da uno Script lato server. È importante farlo perché:

• Roblox blocca l'accesso a tutti i data store dal client in modo che solo il server abbia il permesso di accedere e modificare i dati persistenti dei giocatori.
• Gli script lato server vengono eseguiti in un ambiente centralizzato, assicurando che i dati letti e scritti nel tuo data store siano accurati e validi.
• Poiché gli script lato client vengono eseguiti sul dispositivo del giocatore, qualsiasi giocatore potrebbe potenzialmente sfruttare il gioco e rubare o sovrascrivere i dati di altri giocatori se il client avesse accesso ai tuoi data store.

Dovresti anche dare al tuo data store un nome univoco per mantenere i tuoi dati organizzati e per prevenire sovrapposizioni o conflitti tra diversi data store. In questo tutorial, il data store che salva e memorizza l'inventario dell'oro del giocatore si chiama PlayerGold.

Per creare il data store PlayerGold:

1. Apri lo script GoldManager esistente sotto ServerScriptService.

   

2. In cima allo script, inizializza il DataStoreService e chiama GetDataStore con la stringa "PlayerGold".

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

Salva e carica i dati del giocatore

I data store sono composti da chiavi, che identificano i dati, e valori, che memorizzano i dati.

In questo tutorial, la chiave è l'userId del giocatore e il valore è la quantità di oro che ha raccolto. Per utilizzare questa chiave e valore per salvare e caricare i dati del giocatore:

1. Nello script GoldManager, aggiungi una funzione di supporto chiamata saveGold per salvare l'oro del giocatore nel data store PlayerGold.

   local function saveGold(userId, value)
      local success, err = pcall(function()
         -- `userId` è l'ID unico del giocatore
         -- `value` è la quantità di oro da salvare per quel giocatore
         goldStore:SetAsync(userId, value)
      end)
   end

2. OPZIONALE

   Aggiungi un avviso a saveGold che stampi l'ID del giocatore e un messaggio di errore. Anche se non è obbligatorio, questo passaggio è una buona pratica per facilitare il debug nel caso in cui la tua funzione fallisca.

   local function saveGold(userId, value)
      local success, err = pcall(function()
         -- `userId` è l'ID unico del giocatore
         -- `value` è la quantità di oro da salvare per quel giocatore
         goldStore:SetAsync(userId, value)
      end)
      if not success then
         warn("[ERRORE DI SALVATAGGIO] Impossibile salvare l'oro per", userId, ":", err)
      end
   end

3. Modifica l'evento onPlayerAdded per caricare l'oro del giocatore quando si unisce per la prima volta al gioco. La funzione aggiornata onPlayerAdded:

   • Prova a caricare il contenuto all'interno del data store PlayerGold. Restituisce o l'oro salvato del giocatore o un valore di 0 se il giocatore non ha oro o non ha mai giocato al gioco prima.
   • Ti fornisce un registro di debug per aiutarti a fare debug del tuo codice più facilmente. Questo registro di debug include l'oro salvato del giocatore che si unisce, o un messaggio di errore se onPlayerAdded non riesce ad accedere al data store.
   • Aggiorna l'interfaccia utente per visualizzare l'oro salvato del giocatore sullo schermo.

   local function onPlayerAdded(player)
      local userId = player.UserId
   
      local success, storedGold = pcall(function()
         return goldStore:GetAsync(userId)
      end)
   
      if success then
         local currentGold = storedGold or 0
         playerGold[userId] = currentGold
   
         uiEvent:FireClient(player, {
            gold = currentGold,
            doTween = false,
            showAlert = not success
         })
      else
         uiEvent:FireClient(player, { showAlert = true })
         warn("Impossibile caricare l'oro per", player.Name)
      end
   end

4. Modifica l'evento onPlayerRemoving per chiamare la funzione saveGold che hai creato in precedenza e salvare l'oro del giocatore quando lascia il gioco.

   local function onPlayerRemoving(player)
      local userId = player.UserId
   
      if playerGold[userId] then
         saveGold(userId, playerGold[userId])
      end
   end

Salvataggio automatico dei dati del giocatore

Salvare automaticamente i dati di un giocatore è una buona pratica perché protegge il giocatore dalla perdita dei propri dati. Se salvi i dati del giocatore solo quando lasciano il gioco con onPlayerRemoving, potresti perdere il loro ultimo progresso se si disconnettono inaspettatamente dal server.

Per autosalvare i dati del giocatore:

1. Crea una nuova costante per determinare con quale frequenza vuoi che il tuo gioco salvi automaticamente i dati del giocatore. Una costante è una variabile il cui valore non cambia mentre il gioco è in esecuzione. Puoi utilizzare questa costante per fare riferimento all'intervallo di salvataggio automatico attraverso il tuo script e per regolare facilmente la frequenza di salvataggio automatico.

   -- Questo numero è in secondi
   local AUTOSAVE_INTERVAL = 30

2. Aggiungi una coroutine di salvataggio automatico alla funzione onPlayerAdded esistente per creare un ciclo in background che si esegue mentre il giocatore è all'interno del gioco. Una coroutine è una funzione che viene eseguita in modo asincrono; può sospendersi in determinati punti, riprendere da dove si era fermata e funzionare in parallelo con altre parti del tuo script senza bloccarle.

   In questo script, il ciclo di background della coroutine di salvataggio automatico attende il numero di secondi nella tua costante AUTOSAVE_INTERVAL e poi chiama la funzione saveGold che hai creato in precedenza.

   coroutine.wrap(function()
      while player.Parent do
         task.wait(AUTOSAVE_INTERVAL)
   
         if playerGold[userId] then
            print("[AUTOSAVE] Salvataggio di", playerGold[userId], "oro per", player.Name)
            saveGold(userId, playerGold[userId])
         end
      end
   end)()

Salva e carica la posizione del giocatore

Per salvare la posizione di un giocatore, lavora con il suo Character anziché con l'oggetto Player stesso. Un Character di un giocatore rappresenta il suo modello fisico nel mondo 3D e ha le coordinate per la posizione e l'orientamento correnti, mentre l'oggetto Player rappresenta solo l'account utente.

Poiché i data store possono solo salvare tipi di dati di base come numeri, stringhe e tabelle, non puoi memorizzare direttamente oggetti complessi come valori Vector3 o CFrame. Per salvare la posizione di un giocatore, devi suddividerla in tre numeri separati (le coordinate X, Y e Z) e salvarli individualmente. Quando carichi la posizione in seguito, puoi ricostruire il Vector3 utilizzando le coordinate salvate.

Per salvare e caricare la posizione del personaggio:

1. Apri lo script esistente PositionManager sotto ServerScriptService.

2. In cima allo script, inizializza il DataStoreService e chiama GetDataStore con la stringa "PlayerPosition".

   local DataStoreService = game:GetService("DataStoreService")
   local positionStore = DataStoreService:GetDataStore("PlayerPosition")

3. Aggiungi una funzione di supporto chiamata savePosition che accetta un userId del giocatore e una posizione Vector3. Poiché non puoi salvare i valori Vector3 direttamente, converte la posizione in una tabella di numeri X, Y, Z.

   local function savePosition(player, position)
      local userId = player.UserId
      
      local success, err = pcall(function()
         positionStore:SetAsync(userId, {position.X, position.Y, position.Z})
      end)
   end

4. OPZIONALE

   Aggiungi un avviso a savePosition che stampi un messaggio di errore e il nome del giocatore per il quale non sei riuscito a salvare la posizione. Anche se non è obbligatorio, questo passaggio è una buona pratica per facilitare il debug nel caso in cui la tua funzione fallisca.

   local function savePosition(player, position)
      local userId = player.UserId
      
      local success, err = pcall(function()
         positionStore:SetAsync(userId, {position.X, position.Y, position.Z})
      end)
   
      if not success then
         warn("Impossibile salvare la posizione per", player.Name, ":", err)
      end
   end

5. Aggiungi un'altra funzione di supporto chiamata loadPosition per caricare le coordinate salvate per un giocatore nel data store PlayerPosition. Usa PivotTo per ripristinare la posizione del personaggio nel mondo. Dal momento che la posizione salvata del giocatore viene restituita come tabella, devi ricostruire un Vector3 e poi convertirlo in un CFrame per muovere il personaggio.

   local function loadPosition(userId, character)
      local userId = player.UserId
   
      local success, savedCoords = pcall(function()
         return positionStore:GetAsync(userId)
      end)
   
      if success and savedCoords then
         local pos = Vector3.new(savedCoords[1], savedCoords[2], savedCoords[3])
         print("Posizione ripristinata per", player.Name)
         character:PivotTo(CFrame.new(pos))
      elseif not success then
         warn("Impossibile caricare la posizione per", player.Name)
      end
   end

6. Modifica l'evento onPlayerAdded per impostare la logica di posizione per ogni giocatore che si unisce al tuo gioco. All'interno della funzione onPlayerAdded aggiornata:

   • CharacterAdded chiama loadPosition per ripristinare l'ultima posizione nota del personaggio quando il personaggio di un giocatore appare.
   • CharacterRemoving chiama savePosition per salvare la posizione corrente del personaggio del giocatore se viene rimosso dal gioco.
   • GetPivot ottiene l'esatta posizione del personaggio nel mondo al momento in cui viene rimosso.

   local function onPlayerAdded(player)
      local userId = player.UserId
   
      player.CharacterAdded:Connect(function(character)
         loadPosition(player, character)
      end)
   
      player.CharacterRemoving:Connect(function(character)
         local pos = character:GetPivot().Position
         savePosition(player, pos)
      end)
   end
   
   Player.PlayerAdded:Connect(onPlayerAdded)

Codice finale

Ecco i seguenti frammenti di codice per gli script completi GoldManager e PositionManager. Puoi incollarli ed eseguirli direttamente nel file Gold Rush tutorial salvataggio dati - Inizio .rbxl in Studio.

GoldManager

-- Ottieni i servizi
-- Ottieni i servizi
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local DataStoreService = game:GetService("DataStoreService")

-- Evento remoto per aggiornare l'interfaccia utente
local uiEvent = ReplicatedStorage:WaitForChild("UIEvent")

-- Data store per salvare i frammenti d'oro del giocatore
local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Tabella per memorizzare i frammenti d'oro del giocatore per una singola sessione
local playerGold = {}

-- Costanti
local GOLD_VALUE = 10           -- Quanto vale ogni frammento d'oro
local GOLD_REGEN_DELAY = 2      -- Il ritardo prima che un frammento riappaia (in secondi)
local AUTOSAVE_INTERVAL = 30    -- Con quale frequenza i frammenti del giocatore vengono salvati (in secondi)

-- Funzione per gestire la raccolta di un frammento d'oro da parte del giocatore
local function processGoldTouch(chunk, player)
	-- Nascondi il frammento quando il giocatore lo raccoglie
	chunk.Parent = nil

	-- Aggiungi il frammento al punteggio oro del giocatore per la sessione
	local userId = player.UserId
	
	playerGold[userId] = (playerGold[userId] or 0) + GOLD_VALUE
	print(player.Name, "ora ha", playerGold[userId], "d'oro")

	-- Aggiorna l'interfaccia utente per riflettere il nuovo punteggio d'oro per questa sessione
	uiEvent:FireClient(player, {
		gold = playerGold[userId],
		doTween = true,
		showAlert = false
	})

	-- Aspetta un po' e poi riapparirà il frammento d'oro appena raccolto
	task.delay(GOLD_REGEN_DELAY, function()
		chunk.Parent = workspace.GoldChunks
	end)
end

-- Cicla attraverso tutte le parti contrassegnate come "Gold" e collegale al rilevamento del tocco
for _, chunk in ipairs(CollectionService:GetTagged("Gold")) do
	chunk.Touched:Connect(function(otherPart)
		local player = Players:GetPlayerFromCharacter(otherPart.Parent)
		if player then
			processGoldTouch(chunk, player)
		end
	end)
end

-- Funzione per salvare l'oro del giocatore nel data store
local function saveGold(player, value)
	local userId = player.UserId
	
	local success, err = pcall(function()
		goldStore:SetAsync(userId, value)
	end)
	if not success then
		warn("Impossibile salvare l'oro per", player.Name, ":", err)
	end
end

-- Funzione per gestire il giocatore che si unisce al gioco
local function onPlayerAdded(player)
	local userId = player.UserId
	
	print(player.Name, "si è unito al gioco")

	-- Prova a caricare l'oro del giocatore dal data store
	local success, storedGold = pcall(function()
		return goldStore:GetAsync(userId)
	end)

	if success then
		-- Imposta il punteggio oro della sessione corrente utilizzando il valore del data store per il giocatore
		local currentGold = storedGold or 0
		playerGold[userId] = currentGold

		-- Aggiorna l'interfaccia utente con il valore del data store per il giocatore
		uiEvent:FireClient(player, {
			gold = currentGold,
			doTween = false,
			showAlert =  false
		})
		print("Caricato", currentGold, "d'oro per", player.Name)

	else

		-- Notifica il giocatore che il suo oro non è stato caricato
		uiEvent:FireClient(player, { showAlert = true })
		warn("Impossibile caricare l'oro per", player.Name)
	end

	-- Avvia la coroutine di salvataggio automatico per salvare l'oro del giocatore ogni 30 secondi
	coroutine.wrap(function()
		while player.Parent do
			task.wait(AUTOSAVE_INTERVAL)
			if playerGold[userId] then
				saveGold(player, playerGold[userId])
				print("Salvataggio automatico di", playerGold[userId], "d'oro per", player.Name)
			end
		end
	end)()
end

-- Funzione per gestire il giocatore che lascia il gioco
local function onPlayerRemoving(player)
	local userId = player.UserId
	print(player.Name, "ha lasciato il gioco")

	-- Controlla se l'oro del giocatore è stato tracciato
	if playerGold[userId] then
		-- Salva l'oro del giocatore nel data store prima che se ne vada
		saveGold(player, playerGold[userId])
	end
end

-- Collega gli eventi di unione e di uscita dei giocatori
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

PositionManager

-- Ottieni i servizi
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Data store per salvare la posizione del giocatore
local positionStore = DataStoreService:GetDataStore("PlayerPosition")

-- Funzione per salvare la posizione del giocatore come tabella di {X, Y, Z}
local function savePosition(player, position)
	local userId = player.UserId 
	
	local success, err = pcall(function()
		positionStore:SetAsync(userId, {position.X, position.Y, position.Z})
	end)
	if not success then
		warn("Impossibile salvare la posizione per", player.Name, ":", err)
	end
end

-- Funzione per caricare l'ultima posizione salvata del giocatore e muovere il suo personaggio
local function loadPosition(player, character)
	local userId = player.UserId
	
	local success, savedCoords = pcall(function()
		return positionStore:GetAsync(userId)
	end)

	if success and savedCoords then
		local pos = Vector3.new(savedCoords[1], savedCoords[2], savedCoords[3])
		print("Posizione ripristinata per", player.Name)
		character:PivotTo(CFrame.new(pos))
	elseif not success then
		warn("Impossibile caricare la posizione per", player.Name)
	end
end

-- Funzione per gestire il giocatore che si unisce al gioco
local function onPlayerAdded(player)
	local userId = player.UserId

	-- Prova a caricare la posizione del giocatore quando il suo personaggio appare
	player.CharacterAdded:Connect(function(character)
		loadPosition(player, character)
	end)

	-- Salva la posizione del giocatore quando il suo personaggio viene rimosso
	player.CharacterRemoving:Connect(function(character)
		local pos = character:GetPivot().Position
		savePosition(player, pos)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)