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 Spieler gesammelt haben, und diesen Betrag auf einem Leaderboard sichtbar machen.

Erstelle ein Modul-Skript zur Aufzeichnung der Münzsammelung

Um die Speicherung und Verwaltung der Münzsammelungsdaten jedes Spielers zu verwalten, musst du ein ModuleScript-Objekt erstellen, das eine Datenstruktur und Funktionen enthält, die auf die Münzsammelungsdaten für jeden Spieler zugreifen. Modul-Skripte sind wiederverwendbare Codes, die andere Skripte anfordern können. In diesem Fall benötigt der CoinService dieses Modul-Skript, damit es die Münzsammelungsdaten aktualisieren kann, wenn Spieler Münzen berühren.

Erstelle PlayerData
Erstelle im ServerStorage ein Modul-Skript mit dem Namen PlayerData mit folgendem 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 Modul-Skript definiert eine PlayerData-Tabelle, die null oder viele playerData-Tabellen enthält, die die Münzsammelungsdaten für einen Spieler repräsentieren. Jedes Skript, das dieses Modul-Skript anfordert, erhält dieselbe Kopie der PlayerData-Tabelle, sodass mehrere Skripte die Münzsammelungsdaten ändern und teilen können.

Die Datenstrukturen deklarieren

Das Modul-Skript 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 festzulegen.

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 Anzahl 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

Definiere einen lokalen Datenzugriffsmechanismus

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 aus der Funktion defaultPlayerData() zurück, um sicherzustellen, dass jeder Spieler einige Daten hat, die mit ihm verknüpft sind. 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 Datenzugriffsmechanismen definieren

getValue() und updateValue() sind öffentlich zugängliche Funktionen, die andere Skripte, die dieses Modul-Skript anfordern, aufrufen können. In unserem Fall verwendet der CoinService diese Funktionen, um die Münzsammelungsdaten 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ünzsammelungsdaten visuell mit einem Leaderboard auf dem Bildschirm darstellen. Roblox enthält ein integriertes System, das automatisch ein Leaderboard mit einer Standard-UI erstellt.

Erstelle Leaderboard
Erstelle im ServerStorage ein Modul-Skript mit dem Namen Leaderboard mit folgendem 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 das Erstellen eines Leaderboards erkennt
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

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

-- Aktualisierung eines Spielerstatwertes
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 genauer 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 gespeichert werden (wie StringValue, IntValue oder NumberValue).


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

-- Erstellen eines neuen Leaderboard-Staatstwertes
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 Stat-Werte für einen bestimmten Spieler oder für 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.


-- Aktualisierung eines Spielerstatwertes
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 Modul-Skripte

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

Aktualisiere CoinService
Ersetze im ServerScriptService den bestehenden CoinService-Skriptcode durch den folgenden:

```lua
-- Initialisieren 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 berührt eine Münze
      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 der Ereignis-Listener
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 Funktion require().
Deklarieren von COIN_AMOUNT_TO_ADD als die Anzahl von Münzen, die hinzugefügt werden, wenn ein Spieler eine Münze einsammelt, und COIN_KEY_NAME als den Schlüssel Namen, der in PlayerData definiert ist.
Erstellen der Hilfsfunktion updatePlayerCoins(), um die Münzzählung des Spielers und den zugehörigen Leaderboard-Stat zu aktualisieren.
Ersetzen der Platzhalteranweisung print() in onCoinTouched() durch einen Aufruf von updatePlayerCoins().

Spieltest

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