Punkte sammeln | Dokumentation - Roblox Creator Hub

In vorherigen Tutorials hast du verschiedene Erlebnisfunktionen erstellt, darunter fading platforms und tödliche Lava. Dieses Tutorial verbindet diese zu einem spielbaren Erlebnis, bei dem Nutzer sehen, wer am längsten überleben kann. Für jede Sekunde, in der sie am Leben bleiben, wird ein Punkt zu ihrem Score hinzugefügt.

Einrichtung

Zuerst musst du die Szene für dein Erlebnis einrichten. Dupliziere die fading platforms, die du im vorherigen Tutorial erstellt hast, und lass die Nutzer darum konkurrieren, so lange wie möglich auf der Plattform zu bleiben.

Du kannst auch tödliche Lava verwenden, um Nutzer zu töten, wenn sie von den Plattformen fallen, oder sie einfach in ihr Verderben fallen lassen. Stelle sicher, dass du einen SpawnLocation an einem Ort platzierst, an dem die Nutzer auf die Plattformen springen können, um mit dem Spielen zu beginnen.

Spawn-Punkt über einem Gitter von Fading Platforms, über einem Lava-Boden

Spielerpunkte

Roblox hat ein eingebautes Leaderboard, um Nutzerdaten anzuzeigen. Wenn du Spielerpunkte über das Leaderboard festlegst, werden sie auf der rechten Seite des Bildschirms im Erlebnis angezeigt.

Leaderboard mit Benutzername und angezeigten Punkten

In späteren Tutorials wirst du mehr anpassbare Möglichkeiten lernen, Informationen anzuzeigen, aber das Leaderboard ist der einfachste Weg, ein sichtbares Punktesystem in Roblox zu erstellen.

Es ist am besten, Skripte, die den Erlebnisstatus einrichten, in ServerScriptService zu platzieren, da sie automatisch ausgeführt werden, wenn das Erlebnis startet. Erstelle in ServerScriptService ein Skript mit dem Namen SetupPoints.

SetupPoints-Skript an seinem Platz in ServerScriptService im Explorer-Fenster

Auf Spieler hören

In Roblox ist ein Service ein Objekt, das eine Vielzahl nützlicher Funktionen ausführt. Der Players-Service hat ein Ereignis namens PlayerAdded, das du nutzen kannst, um Punkte für jeden Nutzer einzurichten, der dem Erlebnis beitritt.

Du kannst über die Funktion GetService im game-Objekt auf Services zugreifen. game ist eine variable, die überall zugänglich ist und alles in deinem Erlebnis enthält.

Erstelle eine Variable für den Players-Service mit game:GetService("Players").
Erstelle eine Funktion namens onPlayerAdded, die einen Parameter für den kommenden Spieler hat.

Verbinde die onPlayerAdded-Funktion mit dem PlayerAdded-Ereignis.


local Players = game:GetService("Players")

local function onPlayerAdded(player)

end

Players.PlayerAdded:Connect(onPlayerAdded)

Wenn du eine Variable für einen Service deklarierst, ist es am besten, sie mit dem genauen Namen des Services zu benennen ("Players"), auch wenn dies bedeutet, die üblichen Benennungsstandards für Variablen zu brechen.

Erstelle einen Stats-Ordner

Um die Punkte eines Nutzers im Leaderboard anzuzeigen, musst du nur einen neuen Folder in dem Player-Objekt erstellen, der "leaderstats" heißt, und ihre Punkte dort ablegen. Neue Objekte können innerhalb eines Skripts über die Funktion Instance.new() erstellt werden.

Erstelle ein neues Folder-Objekt mit Instance.new("Folder") und speichere das Ergebnis in einer neuen Variablen namens leaderstats.


local function onPlayerAdded(player)
	local leaderstats = Instance.new("Folder")
end

Setze die Name-Eigenschaft von leaderstats auf "leaderstats".

Mache leaderstats zum Elternteil von player.


local Players = game:GetService("Players")

local function onPlayerAdded(player)
	local leaderstats = Instance.new("Folder")
   leaderstats.Name = "leaderstats"
   leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)

Stelle sicher, dass du den Ordner genau so benennst, wie hier gezeigt ("leaderstats"), da es sonst nicht funktioniert!

Erstelle die Punkte

Das Leaderboardsystem liest alle Werte im leaderstats-Ordner und zeigt alles, was es findet.

Um eine Statistik hinzuzufügen, die die Punkte eines Spielers verfolgt, kann ein neues IntValue-Objekt im leaderstats-Ordner gespeichert werden. Der Name des Wertobjekts wird zusammen mit dem aktuellen Wert angezeigt.

Verwende eine Variable namens points, um ein neues IntValue-Objekt mit Instance.new() zu erstellen.
Setze den Name auf "Points".
Setze den Value auf 0; dies ist das, was das Leaderboard zunächst für den Spieler anzeigen wird.
Mache das points-Objekt zum Elternteil des leaderstats-Ordners.


local Players = game:GetService("Players")

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats
end

Players.PlayerAdded:Connect(onPlayerAdded)

Teste dein Erlebnis, und du solltest das Leaderboard in der oberen rechten Ecke sehen, mit den Namen deiner Nutzer und einer Punktzahl neben ihnen.

Zeit zählen

Jeder Nutzer sollte einen Punkt für jede Sekunde verdienen, in der sie am Leben sind. Eine while-Schleife und die Funktion task.wait() können verwendet werden, um den Wert der Punkte jede Sekunde zu aktualisieren.

Am Ende des Skripts erstelle eine while-Schleife mit true als Bedingung.
In der Schleife task.wait() für 1 Sekunde.


Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Spielerliste

Um Code für jeden Nutzer im Erlebnis auszuführen, musst du durch das Array der Nutzer iterieren, das von der Funktion GetPlayers zurückgegeben wird.

Ein Array ist eine Liste von Elementen, die in Reihenfolge gespeichert sind. Jedes Element kann über seine Index-Position, beginnend bei 1, zugegriffen werden. Du kannst die Länge eines Arrays ermitteln, indem du es mit # voranstellst.

Speichere das Ergebnis von Players:GetPlayers() in einer playerList-Variablen.
Erstelle eine for-Schleife mit einem Startwert von 1 und einem Endwert von #playerList, damit du bei jedem Spieler eine Iteration der Schleife erhältst.


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    -- Füge hier deine Logik für jeden Spieler in der playerList hinzu
  end
end

Punkte vergeben

Um jedem Nutzer in der for-Schleife einen Punkt zu vergeben, musst du den Nutzer aus dem Array herausbekommen und 1 zum Points-Objekt hinzufügen, das in ihrem leaderstats-Ordner gespeichert ist.

Objekte, die in einem Array gespeichert sind, werden mit eckigen Klammern zugegriffen - zum Beispiel kann das erste Element im playerList-Array mit playerList[1] erreicht werden. Wenn du playerList[currentPlayer] in der for-Schleife schreibst, kannst du mit jeder Iteration der Schleife jeden Nutzer in der Liste durchlaufen.

Speichere den Nutzer bei playerList[currentPlayer] in einer Variablen namens player.
Speichere das Points-Objekt des Nutzers in einer Variablen namens points.
Setze die Value-Eigenschaft von points auf points.Value + 1.


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]
    local points = player.leaderstats.Points
    points.Value += 1
  end
end

Teste dein Erlebnis, und du solltest feststellen, dass das Leaderboard die Punktzahl deines Spielers zeigt, die jede Sekunde um 1 zunimmt.

Auf Charaktere hören

Das Ziel des Erlebnisses ist es zu sehen, wer am längsten am Leben bleiben kann, also müssen Nutzer, die sterben, ihre Punkte auf 0 zurückgesetzt bekommen.

Du musst das Character-Modell für den Nutzer abrufen, um zu erkennen, wann sie gestorben sind. Dieses Modell wird nur nach dem Laden des Player-Objekts zum Erlebnis hinzugefügt, und du kannst das Ereignis CharacterAdded verwenden, um zu hören, wann der Charakter bereit ist, verwendet zu werden. Erstelle eine Funktion namens onCharacterAdded mit zwei Parametern: einem für den Charakter und einen für den Spieler.


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")

Obwohl du den Nutzer in den Parametern der onCharacterAdded-Funktion angegeben hast, gibt das tatsächliche CharacterAdded-Ereignis nur den Charakter zurück, nicht den zugehörigen Nutzer. Um das player-Objekt ebenfalls zu übergeben, verwende eine anonyme Funktion für die Ereignisverbindung.


local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Punkte zurücksetzen

Wenn ein Nutzer stirbt, wird automatisch ein Humanoid-Ereignis Died ausgelöst. Du kannst dieses Ereignis verwenden, um herauszufinden, wann du ihre Punkte zurücksetzen musst.

Der Humanoid befindet sich im Charaktermodell, aber die Inhalte dieses Modells werden nur bei der Geburt des Nutzers zusammengesetzt. Um deinen Code sicher zu erstellen, um auf das Humanoid-Objekt zu warten, verwende die Funktion WaitForChild(). Du kannst sie auf jedem übergeordneten Objekt aufrufen und den Namen des Kindes übergeben, auf das du wartest. Erstelle eine Variable, um auf den Humanoid mit character:WaitForChild("Humanoid") zu warten.


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")
end

Die Funktion, die du mit dem Died-Ereignis verbinden musst, ist sehr kurz und wird hier nur benötigt, also kannst du erneut eine anonyme Funktion verwenden.

Verbinde eine neue anonyme Funktion mit dem Died-Ereignis des Humanoids.
In der anonymen Funktion erstelle eine Variable namens points für das Points-Objekt des Nutzers.
Setze die Value-Eigenschaft von points auf 0.


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
  end)
end

Teste dies aus und du wirst sehen, dass die Punktzahl des Nutzers zurückgesetzt wird, wenn er stirbt.

Spieler prüfen

Wenn Nutzer weiterhin Punkte verdienen, auch wenn sie tot sind, entspricht das nicht dem Geist des Erlebnisses, also muss der Code überprüfen, ob die Nutzer am Leben sind, bevor sie einen Punkt vergeben.

Du musst zunächst ein Attribut in der onPlayerAdded-Funktion definieren, das verwendet werden kann, um zu überprüfen, ob der Nutzer am Leben ist. Zu diesem Zeitpunkt ist der Nutzer noch nicht am Leben und nicht gespawnt, da das Charaktermodell noch hinzugefügt werden muss.

Attribute ermöglichen es dir, Objekte in Roblox mit deinen eigenen Daten anzupassen. Ein Attribut besteht aus einem Namen und einem Wert. Du kannst eins auf jedem Objekt mit der Funktion SetAttribute erstellen. Rufe SetAttribute auf player auf, um ein neues Attribut namens "IsAlive" mit dem Wert false zu erstellen.


local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Sobald das Charaktermodell des Nutzers wieder ins Spiel kommt, muss der Wert von IsAlive auf true geändert werden, damit der Nutzer wieder Punkte verdienen kann.

Setze in onCharacterAdded das Attribut IsAlive von player auf true.
Setze in onCharacterDied das Attribut IsAlive von player auf false.


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)

  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

Schließlich sollte IsAlive vor jeder Punktevergabe in der while-Schleife am Ende des Skripts geprüft werden. Die Funktion GetAttribute nimmt den Namen eines Attributs und gibt den Wert zurück. In der while-Schleife wickel den Code zur Vergabe eines Punktes in eine if-Anweisung mit der Bedingung player:GetAttribute("IsAlive").


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()

  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]

    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end

Teste dein Erlebnis jetzt aus, und du solltest feststellen, dass der Nutzer Punkte jede Sekunde sammelt, in der sie am Leben sind, und bei 0 bleibt, wenn sie nicht am Leben sind. Lass deine Freunde mit dir spielen und sehen, wer die höchste Punktzahl erzielen kann.

Das ist erst der Anfang: Du kannst dein Erlebnis für deine Nutzer weiter verbessern. Hier sind einige Tipps:

Fasse den Code für alle Plattformen in ein einziges Skript zusammen, um die Aktualisierung erheblich zu erleichtern.
Erstelle einen Lobby-Bereich, in dem die Nutzer warten, um in den Erlebnisbereich teleportiert zu werden, damit die Nutzer gleichzeitig starten können.
Kündige die Gewinner jeder Runde an.

Abschlusscode


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for i = 1, #playerList do
    local player = playerList[i]
    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end