Spieler können jetzt Münzen sammeln und verlieren, wenn sie sterben, aber die Münzen haben keine Funktion, und der Großteil der 3D-Welt ist ohne die Fähigkeit, sehr hoch zu springen, nicht zugänglich. Dieser Abschnitt des Tutorials zeigt dir, wie du die Logik für dein Spiel abschließt, indem du einen Bildschirm-Button hinzufügst, der Münzen ausgibt, um die Sprungkraft zu erhöhen.
Erstelle den Upgrade-Button
2D-Oberflächen in Roblox bestehen typischerweise aus einer Sammlung von GUI-Komponenten innerhalb eines GUI-Containers. In diesem Fall benötigst du nur eine TextButton-Komponente, die "Upgrade Jump (5 Münzen)" in einem ScreenGui-Container anzeigt.
Erstelle im ReplicatedStorage einen Ordner namens Instances.
Erstelle im Instances-Ordner ein ScreenGui namens JumpPurchaseGui mit deaktiviertem ResetOnSpawn.
Erstelle im JumpPurchaseGui einen TextButton namens JumpButton mit den folgenden Eigenschaften:
- Text: "Upgrade Jump (5 Münzen)"
- TextSize: 25
- AnchorPoint: 1, 1
- Position: {1, 0}, {1, 0}
Erstelle auch im Instances-Ordner eine RemoteFunction namens IncreaseJumpPowerFunction.
Aktiviere schließlich im StarterPlayer-Dienst die Eigenschaft CharacterUseJumpPower.Definiere Sprungkraftdaten
Derzeit wird nur die Münzenanzahl für jeden Spieler im PlayerData-Modulskript gespeichert. Du musst auch die Sprungkraft auf die gleiche Weise speichern und aktualisieren. Da die Funktionen in PlayerData nicht spezifisch für die zu ändernden Daten sind, ist alles, was erforderlich ist, um die Sprungkraft des Spielers zu speichern, das Hinzufügen eines Jump-Schlüssels und die Initialisierung seines Anfangswerts in defaultPlayerData().
Ersetze im ServerStorage den Code des vorhandenen PlayerData-Modulskripts durch den folgenden:
```lua
local PlayerData = {}
PlayerData.COIN_KEY_NAME = "Coins"
PlayerData.JUMP_KEY_NAME = "Jump"
local playerData = {
--[[
[userId: string] = {
["Coins"] = coinAmount: number,
["Jump"] = jumpPower: number
}
--]]
}
local function defaultPlayerData()
return {
[PlayerData.COIN_KEY_NAME] = 0,
[PlayerData.JUMP_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
```Aktualisiere Sprungkraftdaten
Jetzt, da PlayerData in der Lage ist, die Sprungkraft zu verfolgen, musst du Logik auf dem Server implementieren, um die Sprungkraft auf die Anfrage eines Spielers zu erhöhen.
Der Server und der Client können über entweder RemoteEvents oder RemoteFunctions kommunizieren. Remote-Events blockieren nicht, wenn sie ausgelöst werden, und können für die einseitige Kommunikation verwendet werden. Remote-Funktionen hingegen blockieren, bis sie eine Antwort erhalten, was eine zweiseitige Kommunikation ermöglicht.
Für dieses Tutorial muss der Client wissen, ob der Server die Sprungkraft des Spielers erfolgreich erhöht hat, daher solltest du eine Remote-Funktion verwenden.
Erstelle im ServerScriptService ein Skript namens JumpService mit dem folgenden Code:
```lua
-- Dienste
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")
-- Module
local Leaderboard = require(ServerStorage.Leaderboard)
local PlayerData = require(ServerStorage.PlayerData)
-- Ereignisse
local IncreaseJumpPowerFunction = ReplicatedStorage.Instances.IncreaseJumpPowerFunction
local JUMP_KEY_NAME = PlayerData.JUMP_KEY_NAME
local COIN_KEY_NAME = PlayerData.COIN_KEY_NAME
local JUMP_POWER_INCREMENT = 30
local JUMP_COIN_COST = 5
local function updateJumpPower(player, updateFunction)
-- Aktualisiere die Sprungkraft-Tabelle
local newJumpPower = PlayerData.updateValue(player, JUMP_KEY_NAME, updateFunction)
-- Aktualisiere die Sprungkraft des Spielers
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:FindFirstChildWhichIsA("Humanoid")
if humanoid then
humanoid.JumpPower = newJumpPower
-- Aktualisiere das Sprung-Leaderboard
Leaderboard.setStat(player, JUMP_KEY_NAME, newJumpPower)
end
end
local function onPurchaseJumpIncrease(player)
local coinAmount = PlayerData.getValue(player, COIN_KEY_NAME)
if coinAmount < JUMP_COIN_COST then
return false
end
-- Erhöhe die Sprungkraft des Spielers
updateJumpPower(player, function(oldJumpPower)
oldJumpPower = oldJumpPower or 0
return oldJumpPower + JUMP_POWER_INCREMENT
end)
-- Aktualisiere die Münztabelle
local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, function(oldCoinAmount)
return oldCoinAmount - JUMP_COIN_COST
end)
-- Aktualisiere das Münz-Leaderboard
Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
return true
end
local function onCharacterAdded(player)
-- Setze die Sprungkraft des Spielers zurück, wenn der Charakter hinzugefügt wird
updateJumpPower(player, function(_)
return 0
end)
end
-- Initialisiere alle Spieler, die vor dem Verbinden mit dem PlayerAdded-Ereignis hinzugefügt wurden
for _, player in Players:GetPlayers() do
onCharacterAdded(player)
end
-- Normale Initialisierung der Spieler aus dem PlayerAdded-Ereignis
local function onPlayerAdded(player)
player.CharacterAdded:Connect(function()
onCharacterAdded(player)
end)
end
local function onPlayerRemoved(player)
updateJumpPower(player, function(_)
return nil
end)
end
IncreaseJumpPowerFunction.OnServerInvoke = onPurchaseJumpIncrease
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(onPlayerRemoved)
```Die folgenden Abschnitte beschreiben den Code im Detail.
Aktualisiere die Sprungkraftdaten - updateJumpPower() aktualisiert die Sprungkraft des Spielers und das Leaderboard, um visuelles Feedback zu geben. Diese Funktion ähnelt dem Code, der Spieler in Erstelle Spielergefahren schädigt. Vorausgesetzt, ein Character-Modell und Humanoid existieren für den Spieler, dessen Sprungkraft erhöht wird, aktualisiert die Funktion die JumpPower-Eigenschaft auf den neuen Wert, der von PlayerData gespeichert wird, und erhöht ihn um 30. Wenn du möchtest, dass dein Spiel etwas länger dauert, kannst du diese Zahl verringern.
Validiere Serveranfragen - onPurchaseJumpIncrease() überprüft zunächst, ob der Spieler tatsächlich die erforderliche Anzahl an Münzen hat, um das Upgrade zu kaufen. Alle Anfragen von Clients an den Server sollten validiert werden, um zu verhindern, dass böswillige Akteure falsche Anfragen einreichen und dein Spiel ausnutzen.
Füge den Button zur Spieler-GUI hinzu
Ein ScreenGui-Objekt wird nur angezeigt, wenn es einem PlayerGui-Objekt eines Spielers zugeordnet ist. Standardmäßig enthält dies die System-GUI wie das Chatfenster. Du musst jetzt ein Skript im ReplicatedStorage erstellen, um den Upgrade-Button in die GUI jedes Spielers zu kopieren und das Verhalten zu implementieren, wenn der Button gedrückt wird.
Erstelle im ReplicatedStorage ein Skript namens JumpButtonClickHandler mit RunContext auf Client gesetzt und dem folgenden Code:
```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local IncreaseJumpPowerFunction = ReplicatedStorage.Instances.IncreaseJumpPowerFunction
local jumpPurchaseGui = ReplicatedStorage.Instances.JumpPurchaseGui
local jumpButton = jumpPurchaseGui.JumpButton
local function onButtonClicked()
local success, purchased = pcall(IncreaseJumpPowerFunction.InvokeServer, IncreaseJumpPowerFunction)
if not success then
-- purchased wird die Fehlermeldung sein, wenn success false ist
error(purchased)
elseif success and not purchased then
warn("Nicht genug Münzen!")
end
end
jumpButton.Activated:Connect(onButtonClicked)
-- Füge die JumpPurchaseGui zur GUI des Spielers hinzu
jumpPurchaseGui.Parent = playerGui
```Die folgenden Abschnitte beschreiben den Code im Detail.
- Beziehe Referenzen zur GUI und Serverfunktion - Die Variablen IncreaseJumpPowerFunction, jumpPurchaseGui und jumpButton enthalten Referenzen zu der Funktion und GUI, die die Funktion aufrufen, die du später benötigen wirst.
- Definiere den Ereignishandler - onButtonClicked() definiert die Logik für den Fall, dass Benutzer auf den Upgrade-Button klicken. Es verwendet pcall() (geschützte Aufruf) um die RemoteFunction aufzurufen. Jede Client-Server-Kommunikation wie diese erfordert pcall(), um Fehler oder Verbindungsprobleme zu behandeln.
- Verbinde den Handler mit dem Button - Das Activated-Ereignis ist auf allen Plattformen kompatibel, einschließlich Maus-, Touchscreen- oder Gamepad-Kontexten. Es wird ausgelöst, wenn ein Klick, Berührung oder Gamepad-Button losgelassen wird.
Teste das Spiel
Wähle Test aus dem Dropdown-Menü und klicke auf Play. Der Upgrade Jump-Button erscheint in der unteren rechten Ecke.
Versuche, den Button zu klicken, bevor du Münzen sammelst, um zu überprüfen, dass er dir keine zusätzliche Sprungkraft verleiht, und versuche dann, einige Münzen zu sammeln und zu sehen, ob das Upgrade funktioniert, wenn du erneut klickst.
Mit dem vollständigen Code kannst du versuchen, die Schwierigkeit anzupassen: Füge Münzen hinzu, wenn das Tempo zu langsam erscheint, oder entferne einige und verstecke sie an kniffligeren Stellen, wenn Upgrades zu einfach kommen.