Spieler Daten aufzeichnen und anzeigen | Dokumentation

Jetzt, da du erkennen kannst, wann ein Spieler eine Münze gesammelt hat, musst du zählen, wie viele Münzen die Spieler gesammelt haben, und diese Menge auf einem Leaderboard sichtbar machen.

Erstelle ein Modul-Skript zur Aufzeichnung der Münzsammlung

Um die Speicherung und Verwaltung der Münzdaten jedes Spielers zu handhaben, musst du ein ModuleScript-Objekt erstellen, das eine Datenstruktur und Funktionen enthält, die auf die Münzsammlungsdaten für jeden Spieler zugreifen. Modulscripte sind wiederverwendbare Codes, die von anderen Skripten angefordert werden können. In diesem Fall benötigt der CoinService dieses Moduls, damit er die Münzsammlungsdaten aktualisieren kann, wenn Spieler Münzen berühren.

Erstelle PlayerData

Erstelle in ServerStorage ein Modul-Skript mit dem Namen PlayerData und dem folgenden Code:

```lua
local PlayerData = {}
PlayerData.COIN_KEY_NAME = "Coins"

local playerData = {
  --[[
    [userId: string] = {
      ["Coins"] = coinAmount: number
    }
  ]]
}

local function defaultPlayerData()
  return {
    [PlayerData.COIN_KEY_NAME] = 0
  }
end

local function getData(player)
  local data = playerData[tostring(player.UserId)] or defaultPlayerData()
  playerData[tostring(player.UserId)] = data
  return data
end

function PlayerData.getValue(player, key)
  return getData(player)[key]
end

function PlayerData.updateValue(player, key, updateFunction)
  local data = getData(player)
  local oldValue = data[key]
  local newValue = updateFunction(oldValue)

  data[key] = newValue
  return newValue
end

return PlayerData
```

Code-Erklärung

Das Modulskript definiert eine PlayerData-Tabelle, die null oder viele playerData-Tabellen enthält, die die Münzsammlungsdaten für einen Spieler darstellen. Jedes Skript, das dieses Modulskript anfordert, erhält dieselbe Kopie der PlayerData-Tabelle, was es mehreren Skripten ermöglicht, die Münzsammlungsdaten zu ändern und zu teilen.

Die Datenstrukturen deklarieren

Das Modulskript beginnt mit der Deklaration einer leeren Tabelle, PlayerData, die am Ende des Skripts zurückgegeben wird. Es enthält auch Zugriffsmethoden, um Werte in der Tabelle zu erhalten und zu setzen.

Die playerData-Tabelle enthält Kommentare, die die Struktur der Tabelle beschreiben, was den Code leichter verständlich macht. In diesem Fall enthält eine playerData-Tabelle eine userId und ein entsprechendes Feld namens Coins, das die Menge der gesammelten Münzen für diesen Spieler darstellt.

local PlayerData = {}
PlayerData.COIN_KEY_NAME = "Coins"

local playerData = {
  --[[
    [userId: string] = {
        ["Coins"] = coinAmount: number
    }
  ]]
}

...

return PlayerData

Eine lokale Datenzugriffs-Funktion definieren

getData() ist eine lokale Funktion, die Daten für eine bestimmte playerData-Tabelle abruft. Wenn ein Spieler keine Münze gesammelt hat, gibt sie eine Tabelle von der Funktion defaultPlayerData() zurück, um sicherzustellen, dass jeder Spieler einige Daten zugeordnet hat. Eine gängige Konvention ist es, einfache, öffentlich zugängliche Funktionen zu erstellen, die die Logik an lokal definierte Funktionen auslagern, die die Hauptarbeit erledigen.

local function defaultPlayerData()
  return {
    [PlayerData.COIN_KEY_NAME] = 0
  }
end

local function getData(player)
  local data = playerData[tostring(player.UserId)] or defaultPlayerData()
  playerData[tostring(player.UserId)] = data
  return data
end

Öffentliche Datenzugriffs-Funktionen definieren

getValue() und updateValue() sind öffentlich zugängliche Funktionen, die von anderen Skripten, die dieses Modulskript anfordern, aufgerufen werden können. In unserem Fall verwendet der CoinService diese Funktionen, um die Münzsammlungsdaten eines Spielers zu aktualisieren, wann immer dieser Spieler eine Münze berührt.

function PlayerData.getValue(player, key)
 return getData(player)[key]
end

function PlayerData.updateValue(player, key, updateFunction)
  local data = getData(player)
  local oldValue = data[key]
  local newValue = updateFunction(oldValue)

  data[key] = newValue
  return newValue
end

Implementiere ein Leaderboard

Du kannst die Münzsammlungsdaten visuell mit einem Leaderboard auf dem Bildschirm darstellen. Roblox enthält ein integriertes System, das automatisch ein Leaderboard mit einer Standardbenutzeroberfläche generiert.

Erstelle Leaderboard

Erstelle in ServerStorage ein Modul-Skript mit dem Namen Leaderboard und dem folgenden Code:

```lua
local Leaderboard = {}

-- Erstellen eines neuen Leaderboards
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' ist ein reservierter Name, den Roblox für die Erstellung eines Leaderboards erkennt
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Erstellen eines neuen Leaderboard-Statistikwerts
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

-- Aktualisieren eines Spielerstatistikwerts
function Leaderboard.setStat(player, statName, value)
  local leaderstats = player:FindFirstChild("leaderstats")
  if not leaderstats then
    leaderstats = setupLeaderboard(player)
  end

  local stat = leaderstats:FindFirstChild(statName)
  if not stat then
    stat = setupStat(leaderstats, statName)
  end

  stat.Value = value
end

return Leaderboard
```

Code-Erklärung

Die folgenden Abschnitte beschreiben, wie das Leaderboard im Detail funktioniert.

Ein Leaderboard erstellen

Die Funktion setupLeaderboard() erstellt eine neue Ordnerinstanz mit dem Namen leaderstats und setzt sie als Kind des angegebenen Spielers. Roblox erkennt automatisch einen Ordner mit dem Namen leaderstats als Container für Statistiken und erstellt ein UI-Element, um die Statistiken anzuzeigen. Es erfordert, dass die Werte in leaderstats als "Wert"-Objekte (wie StringValue, IntValue oder NumberValue) gespeichert werden.

-- Erstellen eines neuen Leaderboards
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' ist ein reservierter Name, den Roblox für die Erstellung eines Leaderboards erkennt
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Erstellen eines neuen Leaderboard-Statistikwerts
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

Spielerstatistiken aktualisieren

setStat() ist die einzige öffentliche Funktion im Leaderboard-Modul. Sie erstellt Statistikwerte für einen bestimmten Spieler oder das Leaderboard selbst, wenn es noch nicht existiert.

FindFirstChild() nimmt den Namen eines Objekts und gibt das Objekt zurück, wenn es existiert, oder nil, wenn nicht. Es ist eine gängige, sichere Methode, um herauszufinden, ob ein Objekt existiert, bevor du es verwendest.

-- Aktualisieren eines Spielerstatistikwerts
function Leaderboard.setStat(player, statName, value)
  local leaderstats = player:FindFirstChild("leaderstats")
  if not leaderstats then
    leaderstats = setupLeaderboard(player)
  end

  local stat = leaderstats:FindFirstChild(statName)
  if not stat then
    stat = setupStat(leaderstats, statName)
  end

  stat.Value = value
end

Integriere die Modulscripte

Mit beiden Modulen an Ort und Stelle, fordere sie im CoinService-Skript an, um die Münzdaten der Spieler zu verwalten und anzuzeigen.

Aktualisiere CoinService

Ersetze im ServerScriptService den Code des bestehenden CoinService-Skripts durch den folgenden:

```lua
-- Initialisierung von Diensten und Variablen
local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

-- Module
local Leaderboard = require(ServerStorage.Leaderboard)
local PlayerData = require(ServerStorage.PlayerData)

local coinsFolder = Workspace.World.Coins
local coins = coinsFolder:GetChildren()

local COIN_KEY_NAME = PlayerData.COIN_KEY_NAME
local COOLDOWN = 10
local COIN_AMOUNT_TO_ADD = 1

local function updatePlayerCoins(player, updateFunction)
  -- Aktualisiere die Münztabelle
  local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, updateFunction)

  -- Aktualisiere das Münz-Leaderboard
  Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
end

-- Definieren des Ereignis-Handlers
local function onCoinTouched(otherPart, coin)
  if coin:GetAttribute("Enabled") then
    local character = otherPart.Parent
    local player = Players:GetPlayerFromCharacter(character)
    if player then
      -- Spieler hat eine Münze berührt
      coin.Transparency = 1
      coin:SetAttribute("Enabled", false)
      updatePlayerCoins(player, function(oldCoinAmount)
        oldCoinAmount = oldCoinAmount or 0
        return oldCoinAmount + COIN_AMOUNT_TO_ADD
      end)

      task.wait(COOLDOWN)
      coin.Transparency = 0
      coin:SetAttribute("Enabled", true)
    end
  end
end

-- Einrichten von Ereignis-Listenern
for _, coin in coins do
  coin:SetAttribute("Enabled", true)
  coin.Touched:Connect(function(otherPart)
    onCoinTouched(otherPart, coin)
  end)
end
```

Code-Erklärung

Die Änderungen am ursprünglichen CoinService-Skript umfassen:

Importieren der PlayerData- und Leaderboard-Module mit der require()-Funktion.
Deklarieren von COIN_AMOUNT_TO_ADD als die Anzahl der Münzen, die hinzugefügt werden, wenn ein Spieler eine Münze sammelt, und COIN_KEY_NAME als den Schlüssel Namen, der in PlayerData definiert ist.
Erstellen der Hilfsfunktion updatePlayerCoins(), um die Münzzahl des Spielers und die zugehörige Leaderboard-Statistik zu aktualisieren.
Ersetzen der Platzhalter-print()-Anweisung in onCoinTouched() durch einen Aufruf von updatePlayerCoins().

Testspiel

Wähle Test aus dem Dropdown-Menü und klicke auf Play. Gehe in eine Münze und bestätige, dass das Leaderboard in der Ecke erscheint und dass deine Münzzahl steigt, während du mehr Münzen sammelst.