Enregistrer les données du joueur avec des magasins de données standard

Les magasins de données sont un service que vous pouvez utiliser pour enregistrer et charger des données de joueur persistantes à travers différentes sessions de joueurs. Ils stockent des informations importantes, comme les progrès d'un joueur ou son inventaire, et vous permettent de les récupérer pour le joueur la prochaine fois qu'il rejoint votre jeu. Sans les magasins de données, un joueur perdrait tous ses progrès chaque fois qu'il quittait le jeu.

Il existe deux types de magasins de données : standard et ordonné. Ce tutoriel utilise des magasins de données standard, qui stockent des données comme des nombres, des chaînes et des tables qui n'ont pas besoin d'être classées ou triées.

En utilisant le fichier de point de départ du tutoriel sur les magasins de données Gold Rush - Démarrer .rbxl et le fichier du tutoriel sur les magasins de données Gold Rush - Terminé .rbxl comme référence, ce tutoriel vous donne les bases dont vous avez besoin pour enregistrer les progrès des joueurs et créer des jeux plus cohérents, y compris des conseils sur :

• Enregistrement et chargement du montant d'or qu'un joueur a collecté.
• Mise à jour de l'interface utilisateur pour afficher l'inventaire d'or du joueur.
• Enregistrement automatique de l'inventaire d'or du joueur toutes les 30 secondes.
• Enregistrement de la position du joueur lorsqu'il quitte le jeu.
• Restauration de la position du joueur lorsqu'il rejoint à nouveau le jeu.

À la fin de ce tutoriel, vous devriez avoir deux scripts avec des magasins de données sous ServerScriptService :

1. Un script GoldManager mis à jour qui suit, charge et enregistre automatiquement l'or du joueur.
2. Un script PositionManager mis à jour qui enregistre la position du joueur lorsqu'il quitte le jeu et restaure sa position lorsqu'il revient au jeu.

Activer l'accès de Studio aux services API

Les magasins de données ne sont pas stockés localement sur votre appareil, donc votre jeu dépend d'une communication serveur à serveur avec l'arrière-plan de Roblox pour les utiliser. Par défaut, Studio restreint cette communication pour éviter les abus ou les utilisations accidentelles. L'accès aux services API dans Studio est désactivé jusqu'à ce que vous l'activiez explicitement pour vous assurer que seuls les jeux de confiance peuvent lire et écrire sur les serveurs backend de Roblox.

Pour activer l'accès de Studio aux services API afin que vous puissiez utiliser des magasins de données :

1. Ouvrez le fichier tutoriel sur les magasins de données Gold Rush - Démarrer .rbxl dans Studio et créez une copie locale.
2. Publiez votre jeu.
3. De retour dans Studio, allez dans Fichier ⟩ Paramètres de l'expérience ⟩ Sécurité.
4. Activez Activer l'accès de Studio aux services API.
5. Enregistrez vos modifications.

Créer un magasin de données standard

Lors de la création d'un magasin de données, vous devez toujours appeler le DataStoreService depuis un Script côté serveur. Cela est important car :

• Roblox bloque tous les accès aux magasins de données du client afin que seul le serveur ait la permission d'accéder et de modifier les données persistantes des joueurs.
• Les scripts côté serveur s'exécutent dans un environnement centralisé, garantissant que les données lues et écrites dans votre magasin de données sont exactes et valides.
• Puisque les scripts côté client s'exécutent sur l'appareil du joueur, tout joueur pourrait potentiellement exploiter le jeu et voler ou écraser les données d'autres joueurs si le client avait accès à vos magasins de données.

Vous devez également donner à votre magasin de données un nom unique pour garder vos données organisées et pour éviter qu'il ne se chevauche ou ne rentre en conflit avec d'autres magasins de données. Dans ce tutoriel, le magasin de données qui enregistre et stocke l'inventaire d'or du joueur est appelé PlayerGold.

Pour créer le magasin de données PlayerGold :

1. Ouvrez le script GoldManager existant sous ServerScriptService.

   

2. En haut du script, initialisez le DataStoreService et appelez GetDataStore avec la chaîne "PlayerGold".

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

Enregistrer et charger les données des joueurs

Les magasins de données sont composés de clés, qui identifient les données, et de valeurs, qui stockent les données.

Dans ce tutoriel, la clé est l'userId du joueur et la valeur est le montant d'or qu'il a collecté. Pour utiliser cette clé et cette valeur pour enregistrer et charger les données des joueurs :

1. Dans le script GoldManager, ajoutez une fonction d'assistance appelée saveGold pour enregistrer l'or du joueur dans le magasin de données PlayerGold.

   local function saveGold(userId, value)
      local success, err = pcall(function()
         -- `userId` est l'ID unique du joueur
         -- `value` est le montant d'or à enregistrer pour ce joueur
         goldStore:SetAsync(userId, value)
      end)
   end

2. OPTIONAL

   Ajoutez un avertissement à saveGold qui imprime l'ID du joueur et un message d'erreur. Bien que cela ne soit pas obligatoire, cette étape est une bonne pratique pour faciliter le débogage en cas d'échec de votre fonction.

   local function saveGold(userId, value)
      local success, err = pcall(function()
         -- `userId` est l'ID unique du joueur
         -- `value` est le montant d'or à enregistrer pour ce joueur
         goldStore:SetAsync(userId, value)
      end)
      if not success then
         warn("[ERREUR D'ENREGISTREMENT] Impossible d'enregistrer l'or pour", userId, ":", err)
      end
   end

3. Modifiez l'événement onPlayerAdded pour charger l'or du joueur lorsqu'il rejoint le jeu pour la première fois. La fonction onPlayerAdded mise à jour :

   • Essaie de charger le contenu à l'intérieur du magasin de données PlayerGold. Elle retourne soit l'or enregistré du joueur, soit une valeur de 0 si le joueur n'a pas d'or ou n'a pas joué au jeu auparavant.
   • Vous fournit un journal de débogage pour vous aider à déboguer votre code plus facilement. Ce journal de débogage inclut l'or enregistré du joueur qui rejoint, ou un message d'erreur si onPlayerAdded n'est pas en mesure d'accéder au magasin de données.
   • Met à jour l'interface utilisateur pour afficher l'or enregistré du joueur sur son écran.

   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("Impossible de charger l'or pour", player.Name)
      end
   end

4. Modifiez l'événement onPlayerRemoving pour appeler la fonction saveGold que vous avez créée précédemment et enregistrer l'or du joueur lorsqu'il quitte le jeu.

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

Enregistrer automatiquement les données des joueurs

Enregistrer automatiquement les données d'un joueur est une bonne pratique car cela protège le joueur de la perte de ses données. Si vous n'enregistrez les données du joueur que lorsqu'il quitte le jeu avec onPlayerRemoving, vous risquez de perdre ses derniers progrès s'il se déconnecte de manière inattendue du serveur.

Pour enregistrer automatiquement les données du joueur :

1. Créez une nouvelle constante pour déterminer à quelle fréquence vous souhaitez que votre jeu enregistre automatiquement les données du joueur. Une constante est une variable dont la valeur ne change pas pendant l'exécution du jeu. Vous pouvez utiliser cette constante pour vous référer à l'intervalle d'enregistrement automatique dans tout votre script et pour ajuster facilement la fréquence d'enregistrement automatique.

   -- Ce nombre est en secondes
   local AUTOSAVE_INTERVAL = 30

2. Ajoutez une coroutine d'enregistrement automatique à la fonction existante onPlayerAdded pour créer une boucle en arrière-plan qui s'exécute tant que le joueur est à l'intérieur du jeu. Une coroutine est une fonction qui s'exécute de manière asynchrone ; elle peut se mettre en pause à certains moments, reprendre là où elle s'était arrêtée et s'exécuter en parallèle avec d'autres parties de votre script sans les bloquer.

   Dans ce script, la boucle d'enregistrement automatique attend le nombre de secondes dans votre constante AUTOSAVE_INTERVAL, puis appelle la fonction saveGold que vous avez créée plus tôt.

   coroutine.wrap(function()
      while player.Parent do
         task.wait(AUTOSAVE_INTERVAL)
   
         if playerGold[userId] then
            print("[ENREGISTREMENT AUTOMATIQUE] Enregistrement de", playerGold[userId], "d'or pour", player.Name)
            saveGold(userId, playerGold[userId])
         end
      end
   end)()

Enregistrer et charger la position du joueur

Pour enregistrer la position d'un joueur, travaillez avec son Character plutôt qu'avec l'objet Player lui-même. Le Character d'un joueur représente son modèle physique dans le monde 3D et possède les coordonnées de sa position actuelle et de son orientation, tandis que l'objet Player ne représente que le compte utilisateur.

Étant donné que les magasins de données ne peuvent enregistrer que des types de données de base comme des nombres, des chaînes et des tables, vous ne pouvez pas stocker directement des objets complexes comme des valeurs de Vector3 ou de CFrame. Pour enregistrer la position d'un joueur, vous devez la diviser en trois nombres séparés (les coordonnées X, Y et Z) et les enregistrer individuellement. Lorsque vous chargez la position plus tard, vous pouvez reconstruire le Vector3 à partir des coordonnées enregistrées.

Pour enregistrer et charger la position du personnage :

1. Ouvrez le script PositionManager existant sous ServerScriptService.

2. En haut du script, initialisez le DataStoreService et appelez GetDataStore avec la chaîne "PlayerPosition".

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

3. Ajoutez une fonction d'assistance appelée savePosition qui prend en entrée un userId de joueur et une position Vector3. Comme vous ne pouvez pas enregistrer directement des valeurs Vector3, convertissez la position en une table de nombres 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. OPTIONAL

   Ajoutez un avertissement à savePosition qui imprime un message d'erreur et le nom du joueur pour lequel vous avez échoué à enregistrer la position. Bien que cela ne soit pas obligatoire, cette étape est une bonne pratique pour faciliter le débogage en cas d'échec de votre fonction.

   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("Impossible d'enregistrer la position pour", player.Name, ":", err)
      end
   end

5. Ajoutez une autre fonction d'assistance appelée loadPosition pour charger les coordonnées enregistrées d'un joueur dans le magasin de données PlayerPosition. Utilisez PivotTo pour restaurer la position du personnage dans le monde. Étant donné que la position enregistrée du joueur est renvoyée sous forme de table, vous devez reconstruire un Vector3 et le convertir en un CFrame pour déplacer le personnage.

   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("Position restaurée pour", player.Name)
         character:PivotTo(CFrame.new(pos))
      elseif not success then
         warn("Impossible de charger la position pour", player.Name)
      end
   end

6. Modifiez l'événement onPlayerAdded pour mettre en place la logique de position pour chaque joueur qui rejoint votre jeu. Dans la fonction onPlayerAdded mise à jour :

   • CharacterAdded appelle loadPosition pour restaurer la dernière localisation connue du personnage lorsqu'un personnage de joueur apparaît.
   • CharacterRemoving appelle savePosition pour enregistrer la position actuelle du personnage du joueur s'il est retiré du jeu.
   • GetPivot obtient l'emplacement exact du personnage dans le monde au moment où ils sont retirés.

   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)

Code final

Voir les extraits de code suivants pour les scripts complets GoldManager et PositionManager. Vous pouvez les coller et les exécuter directement dans le fichier tutoriel sur la sauvegarde des données Gold Rush - Démarrer .rbxl dans Studio.

GoldManager

-- Obtenir les services
-- Obtenir les services
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local DataStoreService = game:GetService("DataStoreService")

-- Événement distant pour mettre à jour l'interface utilisateur
local uiEvent = ReplicatedStorage:WaitForChild("UIEvent")

-- Magasin de données pour enregistrer les morceaux d'or du joueur
local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Table pour stocker les morceaux d'or du joueur pour une seule session
local playerGold = {}

-- Constantes
local GOLD_VALUE = 10           -- Combien vaut chaque morceau d'or
local GOLD_REGEN_DELAY = 2      -- Le délai avant qu'un morceau réapparaisse (en secondes)
local AUTOSAVE_INTERVAL = 30    -- À quelle fréquence les morceaux du joueur sont enregistrés (en secondes)

-- Fonction pour gérer la collecte d'un morceau d'or par le joueur
local function processGoldTouch(chunk, player)
	-- Cacher le morceau lorsque le joueur le collecte
	chunk.Parent = nil

	-- Ajouter le morceau au score d'or du joueur pour la session
	local userId = player.UserId
	
	playerGold[userId] = (playerGold[userId] or 0) + GOLD_VALUE
	print(player.Name, "a maintenant", playerGold[userId], "d'or")

	-- Mettre à jour l'interface utilisateur pour refléter le nouveau score d'or pour cette session
	uiEvent:FireClient(player, {
		gold = playerGold[userId],
		doTween = true,
		showAlert = false
	})

	-- Attendre un peu et ensuite faire réapparaître le morceau d'or qui a été collecté
	task.delay(GOLD_REGEN_DELAY, function()
		chunk.Parent = workspace.GoldChunks
	end)
end

-- Boucle à travers toutes les pièces étiquetées "Gold" et les connecte à la détection de toucher
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

-- Fonction pour enregistrer l'or du joueur dans le magasin de données
local function saveGold(player, value)
	local userId = player.UserId
	
	local success, err = pcall(function()
		goldStore:SetAsync(userId, value)
	end)
	if not success then
		warn("Impossible d'enregistrer l'or pour", player.Name, ":", err)
	end
end

-- Fonction pour gérer l'ajout d'un joueur au jeu
local function onPlayerAdded(player)
	local userId = player.UserId
	
	print(player.Name, "a rejoint le jeu")

	-- Essayer de charger l'or du joueur depuis le magasin de données
	local success, storedGold = pcall(function()
		return goldStore:GetAsync(userId)
	end)

	if success then
		-- Définir le score d'or de la session actuelle en utilisant la valeur du magasin de données pour le joueur
		local currentGold = storedGold or 0
		playerGold[userId] = currentGold

		-- Mettre à jour l'interface utilisateur avec la valeur du magasin de données pour le joueur
		uiEvent:FireClient(player, {
			gold = currentGold,
			doTween = false,
			showAlert =  false
		})
		print("Chargé", currentGold, "d'or pour", player.Name)

	else

		-- Informer le joueur que son or n'a pas pu être chargé
		uiEvent:FireClient(player, { showAlert = true })
		warn("Impossible de charger l'or pour", player.Name)
	end

	-- Démarrer la coroutine d'enregistrement automatique pour enregistrer l'or du joueur toutes les 30 secondes
	coroutine.wrap(function()
		while player.Parent do
			task.wait(AUTOSAVE_INTERVAL)
			if playerGold[userId] then
				saveGold(player, playerGold[userId])
				print("Enregistrement automatique de", playerGold[userId], "d'or pour", player.Name)
			end
		end
	end)()
end

-- Fonction pour gérer le départ du joueur du jeu
local function onPlayerRemoving(player)
	local userId = player.UserId
	print(player.Name, "a quitté le jeu")

	-- Vérifier si l'or du joueur a été suivi
	if playerGold[userId] then
		-- Enregistrer l'or du joueur dans le magasin de données avant qu'il ne parte
		saveGold(player, playerGold[userId])
	end
end

-- Connecter les événements d'ajout et de départ des joueurs
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

PositionManager

-- Obtenir les services
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Magasin de données pour enregistrer la position du joueur
local positionStore = DataStoreService:GetDataStore("PlayerPosition")

-- Fonction pour enregistrer la position du joueur sous forme de table de {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("Impossible d'enregistrer la position pour", player.Name, ":", err)
	end
end

-- Fonction pour charger la dernière position enregistrée du joueur et déplacer son personnage
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("Position restaurée pour", player.Name)
		character:PivotTo(CFrame.new(pos))
	elseif not success then
		warn("Impossible de charger la position pour", player.Name)
	end
end

-- Fonction pour gérer l'ajout d'un joueur au jeu
local function onPlayerAdded(player)
	local userId = player.UserId

	-- Essayer de charger la position du joueur lorsque son personnage apparaît
	player.CharacterAdded:Connect(function(character)
		loadPosition(player, character)
	end)

	-- Enregistrer la position du joueur lorsque son personnage est retiré
	player.CharacterRemoving:Connect(function(character)
		local pos = character:GetPivot().Position
		savePosition(player, pos)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)