Spieler-Daten mit standardmäßigen Datenspeichern speichern

Datenspeicher sind ein Dienst, den Sie verwenden können, um persistente Spieldaten über verschiedene Spielersitzungen hinweg zu speichern und zu laden. Sie speichern wichtige Informationen, wie den Fortschritt oder das Inventar eines Spielers, und ermöglichen es Ihnen, diese für den Spieler beim nächsten Beitritt zu Ihrem Spiel abzurufen. Ohne Datenspeicher würde ein Spieler seinen gesamten Fortschritt verlieren, jedes Mal, wenn er das Spiel verlässt.

Es gibt zwei Arten von Datenspeichern: standardmäßige und geordnete. Dieses Tutorial verwendet standardmäßige Datenspeicher, die Daten wie Zahlen, Zeichenfolgen und Tabellen speichern, die nicht eingestuft oder sortiert werden müssen.

Verwenden Sie die Gold Rush Datenspeicher-Tutorial - Start .rbxl Datei als Ausgangspunkt und die Gold Rush Datenspeicher-Tutorial - Komplett .rbxl Datei als Referenz. Dieses Tutorial vermittelt Ihnen die Grundlage, die Sie benötigen, um den Fortschritt der Spieler zu speichern und konsistentere Spiele zu erstellen, einschließlich Anweisungen zu:

• Speichern und Laden des Betrags an Gold, den ein Spieler gesammelt hat.
• Aktualisieren der Benutzeroberfläche, um das Goldinventar des Spielers anzuzeigen.
• Automatisches Speichern des Goldinventars des Spielers alle 30 Sekunden.
• Speichern der Position des Spielers, wenn er das Spiel verlässt.
• Wiederherstellen der Position des Spielers, wenn er das Spiel erneut betritt.

Am Ende dieses Tutorials sollten Sie zwei Skripte mit Datenspeichern unter ServerScriptService haben:

1. Ein aktualisiertes Skript GoldManager, das das Gold des Spielers verfolgt, lädt und automatisch speichert.
2. Ein aktualisiertes Skript PositionManager, das die Position des Spielers speichert, wenn er das Spiel verlässt, und seine Position wiederherstellt, wenn er zurückkommt.

Studio-Zugriff auf API-Dienste aktivieren

Datenspeicher werden nicht lokal auf Ihrem Gerät gespeichert, sodass Ihr Spiel auf die Server-zu-Server-Kommunikation mit dem Backend von Roblox angewiesen ist, um sie zu verwenden. Standardmäßig beschränkt Studio diese Kommunikation, um Missbrauch oder versehentliche Nutzung zu verhindern. Der Zugriff auf API-Dienste in Studio ist deaktiviert, bis Sie ihn ausdrücklich aktivieren, um sicherzustellen, dass nur vertrauenswürdige Spiele auf die Backend-Server von Roblox lesen und schreiben können.

Um den Studio-Zugriff auf API-Dienste zu aktivieren, damit Sie Datenspeicher verwenden können:

1. Öffnen Sie die Gold Rush Datenspeicher-Tutorial - Start .rbxl Datei in Studio und erstellen Sie eine lokale Kopie.
2. Veröffentlichen Sie Ihr Spiel.
3. Gehen Sie zurück zu Studio, klicken Sie auf Datei ⟩ Erfahrungs Einstellungen ⟩ Sicherheit.
4. Aktivieren Sie Studio-Zugriff auf API-Dienste aktivieren.
5. Speichern Sie Ihre Änderungen.

Einen standardmäßigen Datenspeicher erstellen

Beim Erstellen eines Datenspeichers sollten Sie immer den DataStoreService von einem serverseitigen Script aufrufen. Dies ist wichtig, weil:

• Roblox den gesamten Datenbankzugriff von der Client-Seite blockiert, sodass nur der Server die Berechtigung hat, auf persistente Spieldaten zuzugreifen und diese zu ändern.
• Serverseitige Skripte in einer zentralisierten Umgebung ausgeführt werden, wodurch sichergestellt wird, dass die Daten, die Sie auf Ihrem Datenspeicher lesen und schreiben, genau und gültig sind.
• Da clientseitige Skripte auf dem Gerät des Spielers ausgeführt werden, könnte möglicherweise jeder Spieler das Spiel ausnutzen und die Daten anderer Spieler stehlen oder überschreiben, wenn der Client Zugriff auf Ihre Datenspeicher hätte.

Sie sollten Ihrem Datenspeicher auch einen eindeutigen Namen geben, um Ihre Daten organisiert zu halten und zu verhindern, dass sie in verschiedenen Datenspeichern überlappen oder in Konflikt stehen. In diesem Tutorial wird der Datenspeicher, der das Goldinventar des Spielers speichert und speichert, PlayerGold genannt.

Um den Datenspeicher PlayerGold zu erstellen:

1. Öffnen Sie das vorhandene Skript GoldManager unter ServerScriptService.

   

2. Initialisieren Sie oben im Skript den DataStoreService und rufen Sie GetDataStore mit der Zeichenfolge "PlayerGold" auf.

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

Spieler-Daten speichern und laden

Datenspeicher bestehen aus Schlüsseln, die Daten identifizieren, und Werten, die Daten speichern.

In diesem Tutorial ist der Schlüssel die userId des Spielers und der Wert ist die Menge an Gold, die er gesammelt hat. Um diesen Schlüssel und Wert zu verwenden, um Spieldaten zu speichern und zu laden:

1. Fügen Sie im GoldManager-Skript eine Hilfsfunktion namens saveGold hinzu, um das Gold des Spielers im PlayerGold Datenspeicher zu speichern.

   local function saveGold(userId, value)
      local success, err = pcall(function()
         -- `userId` ist die eindeutige ID des Spielers
         -- `value` ist der Betrag an Gold, der für den Spieler gespeichert werden soll
         goldStore:SetAsync(userId, value)
      end)
   end

2. OPTIONAL

   Fügen Sie eine Warnung zu saveGold hinzu, die die ID des Spielers und eine Fehlermeldung ausgibt. Während dies nicht zwingend erforderlich ist, ist dieser Schritt eine gute Praxis für einfacheres Debugging, falls Ihre Funktion fehlschlägt.

   local function saveGold(userId, value)
      local success, err = pcall(function()
         -- `userId` ist die eindeutige ID des Spielers
         -- `value` ist der Betrag an Gold, der für den Spieler gespeichert werden soll
         goldStore:SetAsync(userId, value)
      end)
      if not success then
         warn("[SPEICHERFEHLER] Gold konnte nicht gespeichert werden für", userId, ":", err)
      end
   end

3. Ändern Sie das onPlayerAdded Ereignis, um das Gold des Spielers zu laden, wenn er das erste Mal in das Spiel eintritt. Die aktualisierte onPlayerAdded Funktion:

   • Versucht, den Inhalt des PlayerGold Datenspeichers zu laden. Sie gibt entweder das gespeicherte Gold des Spielers oder einen Wert von 0 zurück, wenn der Spieler kein Gold hat oder das Spiel vorher nicht gespielt hat.
   • Bietet Ihnen ein Protokoll, das Ihnen hilft, Ihren Code einfacher zu debuggen. Dieses Debug-Protokoll enthält das gespeicherte Gold des einsteigenden Spielers oder eine Fehlermeldung, falls onPlayerAdded nicht auf den Datenspeicher zugreifen kann.
   • Aktualisiert die Benutzeroberfläche, um das gespeicherte Gold des Spielers auf seinem Bildschirm anzuzeigen.

   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("Gold konnte nicht geladen werden für", player.Name)
      end
   end

4. Ändern Sie das onPlayerRemoving Ereignis, um die saveGold Funktion, die Sie zuvor erstellt haben, aufzurufen und das Gold des Spielers zu speichern, wenn er das Spiel verlässt.

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

Spieler-Daten automatisch speichern

Das automatische Speichern der Spieldaten eines Spielers ist eine gute Praxis, da es den Spieler vor dem Verlust seiner Daten schützt. Wenn Sie die Daten eines Spielers nur speichern, wenn er das Spiel mit onPlayerRemoving verlässt, könnten Sie ihren neuesten Fortschritt verlieren, wenn sie unerwartet von dem Server getrennt werden.

Um die Daten des Spielers automatisch zu speichern:

1. Erstellen Sie eine neue Konstante, um zu bestimmen, wie oft Sie möchten, dass Ihr Spiel die Spieldaten des Spielers automatisch speichert. Eine Konstante ist eine Variable, deren Wert sich während der Ausführung des Spiels nicht ändert. Sie können diese Konstante verwenden, um auf das automatische Speicherintervall in Ihrem Skript zu verweisen und die Häufigkeit des automatischen Speicherns leicht anzupassen.

   -- Diese Zahl ist in Sekunden
   local AUTOSAVE_INTERVAL = 30

2. Fügen Sie ein automatisches Speicher-Koroutine zu der vorhandenen onPlayerAdded Funktion hinzu, um eine Hintergrundschleife zu erstellen, die läuft, während der Spieler im Spiel ist. Eine Koroutine ist eine Funktion, die asynchron ausgeführt wird; sie kann an bestimmten Punkten pausieren, dort weitermachen, wo sie aufgehört hat, und parallel zu anderen Teilen Ihres Skripts laufen, ohne diese zu blockieren.

   In diesem Skript wartet die automatische Speicher-Koroutine Hintergrundschleife auf die Anzahl der Sekunden in Ihrer AUTOSAVE_INTERVAL Konstante, und ruft dann die saveGold Funktion auf, die Sie zuvor erstellt haben.

   coroutine.wrap(function()
      while player.Parent do
         task.wait(AUTOSAVE_INTERVAL)
   
         if playerGold[userId] then
            print("[AUTOSAVE] Speichern von", playerGold[userId], "Gold für", player.Name)
            saveGold(userId, playerGold[userId])
         end
      end
   end)()

Spielerposition speichern und laden

Um die Position eines Spielers zu speichern, arbeiten Sie mit seinem Character anstelle des Player Objekts selbst. Der Character eines Spielers repräsentiert sein physisches Modell in der 3D-Welt und hat die Koordinaten für seine aktuelle Position und Ausrichtung, während das Player Objekt nur das Benutzerkonto darstellt.

Da Datenspeicher nur grundlegende Datentypen wie Zahlen, Zeichenfolgen und Tabellen speichern können, können Sie keine komplexen Objekte wie Vector3 oder CFrame Werte direkt speichern. Um die Position eines Spielers zu speichern, müssen Sie sie in drei separate Zahlen (die X-, Y- und Z-Koordinaten) aufteilen und sie individuell speichern. Beim Laden der Position später können Sie das Vector3 mit den gespeicherten Koordinaten wiederherstellen.

Um die Position des Charakters zu speichern und zu laden:

1. Öffnen Sie das vorhandene PositionManager Skript unter ServerScriptService.

2. Initialisieren Sie oben im Skript den DataStoreService und rufen Sie GetDataStore mit der Zeichenfolge "PlayerPosition" auf.

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

3. Fügen Sie eine Hilfsfunktion namens savePosition hinzu, die die userId eines Spielers und eine Vector3 Position entgegennimmt. Da Sie Vector3 Werte nicht direkt speichern können, konvertieren Sie die Position in eine Tabelle von X, Y, Z Zahlen.

   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

   Fügen Sie eine Warnung zu savePosition hinzu, die eine Fehlermeldung und den Namen des Spielers ausgibt, für den Sie die Position nicht speichern konnten. Während dies nicht zwingend erforderlich ist, ist dieser Schritt eine gute Praxis für einfacheres Debugging, falls Ihre Funktion fehlschlägt.

   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("Konnte die Position für", player.Name, "nicht speichern:", err)
      end
   end

5. Fügen Sie eine weitere Hilfsfunktion namens loadPosition hinzu, um die gespeicherten Koordinaten für einen Spieler im PlayerPosition Datenspeicher zu laden. Verwenden Sie PivotTo, um die Position des Charakters in der Welt wiederherzustellen. Da die gespeicherte Position des Spielers als Tabelle zurückgegeben wird, müssen Sie ein Vector3 erneut aufbauen und dann in ein CFrame umwandeln, um den Charakter zu bewegen.

   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 wiederhergestellt für", player.Name)
         character:PivotTo(CFrame.new(pos))
      elseif not success then
         warn("Konnte die Position für", player.Name, "nicht laden")
      end
   end

6. Ändern Sie das onPlayerAdded Ereignis, um die Positionslogik für jeden Spieler einzurichten, der Ihrem Spiel beitritt. In der aktualisierten onPlayerAdded Funktion:

   • CharacterAdded ruft loadPosition auf, um die letzte bekannte Position des Charakters wiederherzustellen, wenn ein Charakter eines Spielers erscheint.
   • CharacterRemoving ruft savePosition auf, um die aktuelle Position des Charakters des Spielers zu speichern, falls er aus dem Spiel entfernt wird.
   • GetPivot erhält die genaue Position des Charakters in der Welt, als er entfernt wird.

   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)

Endgültiger Code

Siehe die folgenden Code-Snippets für die vollständigen Skripte GoldManager und PositionManager. Sie können sie direkt in die Gold Rush Speicherdaten Tutorial - Start .rbxl Datei in Studio einfügen und ausführen.

GoldManager

-- Dienste abrufen
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local DataStoreService = game:GetService("DataStoreService")

-- Remote-Event zur Aktualisierung der Benutzeroberfläche
local uiEvent = ReplicatedStorage:WaitForChild("UIEvent")

-- Datenspeicher zum Speichern der Goldhaufen des Spielers
local goldStore = DataStoreService:GetDataStore("PlayerGold")

-- Tabelle zum Speichern der Goldhaufen des Spielers für eine einzelne Sitzung
local playerGold = {}

-- Konstanten
local GOLD_VALUE = 10           -- Wie viel jeder Goldhaufen wert ist
local GOLD_REGEN_DELAY = 2      -- Die Verzögerung, bis ein Haufen wieder erscheint (in Sekunden)
local AUTOSAVE_INTERVAL = 30    -- Wie oft die Goldhaufen des Spielers gespeichert werden (in Sekunden)

-- Funktion zum Handhaben des Sammelns eines Goldhaufens durch den Spieler
local function processGoldTouch(chunk, player)
	-- Den Haufen ausblenden, wenn der Spieler ihn aufnimmt
	chunk.Parent = nil

	-- Den Haufen zum Goldpunktestand des Spielers in dieser Sitzung hinzufügen
	local userId = player.UserId
	
	playerGold[userId] = (playerGold[userId] or 0) + GOLD_VALUE
	print(player.Name, "hat jetzt", playerGold[userId], "Gold")

	-- Benutzeroberfläche aktualisieren, um den neuen Goldpunktestand für diese Sitzung widerzuspiegeln
	uiEvent:FireClient(player, {
		gold = playerGold[userId],
		doTween = true,
		showAlert = false
	})

	-- Warten und dann den Goldhaufen zurückbringen, der gerade gesammelt wurde
	task.delay(GOLD_REGEN_DELAY, function()
		chunk.Parent = workspace.GoldChunks
	end)
end

-- Durchlaufen aller Teile, die mit "Gold" getaggt sind und sie mit der Berührungserkennung verbinden
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

-- Funktion zum Speichern des Goldes des Spielers im Datenspeicher
local function saveGold(player, value)
	local userId = player.UserId
	
	local success, err = pcall(function()
		goldStore:SetAsync(userId, value)
	end)
	if not success then
		warn("Konnte das Gold für", player.Name, "nicht speichern:", err)
	end
end

-- Funktion zur Handhabung des Beitritts des Spielers zum Spiel
local function onPlayerAdded(player)
	local userId = player.UserId
	
	print(player.Name, "ist dem Spiel beigetreten")

	-- Versuchen, das Gold des Spielers aus dem Datenspeicher zu laden
	local success, storedGold = pcall(function()
		return goldStore:GetAsync(userId)
	end)

	if success then
		-- Den aktuellen Sitzungsgoldpunktestand mit dem Datenspeicherwert für den Spieler setzen
		local currentGold = storedGold or 0
		playerGold[userId] = currentGold

		-- Die Benutzeroberfläche mit dem Datenspeicherwert für den Spieler aktualisieren
		uiEvent:FireClient(player, {
			gold = currentGold,
			doTween = false,
			showAlert = false
		})
		print("Geladen", currentGold, "Gold für", player.Name)

	else

		-- Den Spieler benachrichtigen, dass sein Gold nicht geladen werden konnte
		uiEvent:FireClient(player, { showAlert = true })
		warn("Konnte das Gold für", player.Name, "nicht laden")
	end

	-- Starten Sie die automatische Speicher-Koroutine, um das Gold des Spielers alle 30 Sekunden zu speichern
	coroutine.wrap(function()
		while player.Parent do
			task.wait(AUTOSAVE_INTERVAL)
			if playerGold[userId] then
				saveGold(player, playerGold[userId])
				print("Automatisches Speichern von", playerGold[userId], "Gold für", player.Name)
			end
		end
	end)()
end

-- Funktion zur Handhabung des Verlassens des Spiels durch den Spieler
local function onPlayerRemoving(player)
	local userId = player.UserId
	print(player.Name, "hat das Spiel verlassen")

	-- Überprüfen, ob das Gold des Spielers verfolgt wurde
	if playerGold[userId] then
		-- Das Gold des Spielers vor dem Verlassen in den Datenspeicher speichern
		saveGold(player, playerGold[userId])
	end
end

-- Ereignisse für das Beitreten und Verlassen von Spielern verbinden
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoving)

PositionManager

-- Dienste abrufen
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

-- Datenspeicher zum Speichern der Position des Spielers
local positionStore = DataStoreService:GetDataStore("PlayerPosition")

-- Funktion zum Speichern der Position des Spielers als Tabelle von {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("Konnte die Position für", player.Name, "nicht speichern:", err)
	end
end

-- Funktion zum Laden der zuletzt gespeicherten Position des Spielers und Bewege seinen Charakter
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 wiederhergestellt für", player.Name)
		character:PivotTo(CFrame.new(pos))
	elseif not success then
		warn("Konnte die Position für", player.Name, "nicht laden")
	end
end

-- Funktion zur Handhabung des Beitritts des Spielers zum Spiel
local function onPlayerAdded(player)
	local userId = player.UserId

	-- Versuchen, die Position des Spielers zu laden, wenn ihr Charakter erscheint
	player.CharacterAdded:Connect(function(character)
		loadPosition(player, character)
	end)

	-- Die Position des Spielers speichern, wenn sein Charakter entfernt wird
	player.CharacterRemoving:Connect(function(character)
		local pos = character:GetPivot().Position
		savePosition(player, pos)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)