Skripte einen Upgrade-Button | Dokumentation

Spieler können jetzt Münzen sammeln und verlieren diese, 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 Ihnen, wie Sie die Logik für Ihr Erlebnis abschließen, indem Sie einen auf dem Bildschirm angezeigten Button hinzufügen, der Münzen verwendet, um die Sprungkraft zu erhöhen.

Erstellen Sie den Upgrade-Button

2D-Oberflächen in Roblox bestehen typischerweise aus einer Sammlung von GUI-Komponenten innerhalb eines GUI-Containers. In diesem Fall benötigen Sie lediglich eine TextButton-Komponente, die "Upgrade Jump (5 Münzen)" innerhalb eines ScreenGui-Containers anzeigt.

Einrichten der Upgrade-GUI
Erstellen Sie in ReplicatedStorage einen Ordner namens Instances.

Erstellen Sie im Ordner Instances eine ScreenGui namens JumpPurchaseGui mit deaktiviertem ResetOnSpawn.

Erstellen Sie innerhalb von JumpPurchaseGui eine TextButton namens JumpButton mit den folgenden Eigenschaften:
- Text: "Upgrade Jump (5 Münzen)"
- TextSize: 25
- AnchorPoint: 1, 1
- Position: {1, 0}, {1, 0}

Erstellen Sie außerdem im Ordner Instances eine RemoteFunction namens IncreaseJumpPowerFunction.

Aktivieren Sie schließlich im StarterPlayer-Service die CharacterUseJumpPower-Eigenschaft.

Definieren Sie die Sprungkraftdaten

Derzeit wird nur die Münzenanzahl für jeden Spieler im PlayerData-Modulskript gespeichert. Sie müssen 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 des Anfangswerts in defaultPlayerData().

Aktualisieren Sie PlayerData mit Sprungkraft
Ersetzen Sie in ServerStorage den vorhandenen Code des PlayerData-Moduls mit dem Folgenden:

```lua
local PlayerData = {}

PlayerData.COIN_KEY_NAME = "Münzen"
PlayerData.JUMP_KEY_NAME = "Sprung"

local playerData = {
	--[[
		[userId: string] = {
			["Münzen"] = coinAmount: number,
			["Sprung"] = 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
```

Aktualisieren Sie die Sprungkraftdaten

Jetzt, da PlayerData in der Lage ist, die Sprungkraft zu verfolgen, müssen Sie eine Logik auf dem Server implementieren, um die Sprungkraft basierend auf einer Anforderung des Clients zu erhöhen.

Der Server und der Client können entweder über RemoteEvents oder RemoteFunctions kommunizieren. Remote-Events blockieren nicht, wenn sie ausgelöst werden, und können für die Kommunikation in eine Richtung verwendet werden. Remote-Funktionen dagegen blockieren, bis sie eine Antwort erhalten, was eine bidirektionale Kommunikation ermöglicht.

Für dieses Tutorial muss der Client wissen, ob der Server die Sprungkraft des Spielers erfolgreich erhöht hat, daher sollten Sie eine Remote-Funktion verwenden.

Erstellen Sie JumpService
Erstellen Sie in 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)

-- Events
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)
	-- Aktualisieren der Sprungkrafttabelle
	local newJumpPower = PlayerData.updateValue(player, JUMP_KEY_NAME, updateFunction)

	-- Aktualisieren der Sprungkraft des Spielers
	local character = player.Character or player.CharacterAdded:Wait()
	local humanoid = character:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		humanoid.JumpPower = newJumpPower

		-- Aktualisieren des Sprungleitfadens
		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öhen der Sprungkraft des Spielers
	updateJumpPower(player, function(oldJumpPower)
		oldJumpPower = oldJumpPower or 0
		return oldJumpPower + JUMP_POWER_INCREMENT
	end)
	-- Aktualisieren der Münztabelle
	local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, function(oldCoinAmount)
		return oldCoinAmount - JUMP_COIN_COST
	end)
	-- Aktualisieren des Münzleitfadens
	Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
	return true
end

local function onCharacterAdded(player)
	-- Zurücksetzen der Sprungkraft des Spielers, wenn das Charaktermodell hinzugefügt wird
	updateJumpPower(player, function(_)
		return 0
	end)
end

-- Initialisieren von Spielern, die hinzugefügt wurden, bevor das PlayerAdded-Event verbunden wurde
for _, player in Players:GetPlayers() do
	onCharacterAdded(player)
end

-- Normale Initialisierung von Spielern aus dem PlayerAdded-Event
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)
```

Code-Erklärung

Die folgenden Abschnitte beschreiben den Code im Detail.

Aktualisieren Sie die Sprungkraftdaten - updateJumpPower() aktualisiert die Sprungkraft des Spielers und den Leitfaden, um visuelles Feedback zu geben. Diese Funktion ähnelt dem Code, der Spieler in Erstellen von Spielergefahren schädigt. Vorausgesetzt, ein Character-Modell und Humanoid existieren für den Spieler, dessen Sprungkraft erhöht wird, aktualisiert die Funktion die Eigenschaft JumpPower auf den neuen Wert, der von PlayerData gespeichert wird, und erhöht sie um 30. Wenn Sie möchten, dass Ihr Spiel etwas länger dauert, können Sie diese Zahl verringern.
Validierung von Serveranfragen - onPurchaseJumpIncrease() überprüft zunächst, ob der Spieler tatsächlich die benötigte 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 stellen und Ihr Spiel ausnutzen.

Fügen Sie den Button zur Spieler-GUI hinzu

Ein ScreenGui-Objekt wird nur angezeigt, wenn es dem PlayerGui-Objekt eines Spielers zugeordnet ist. Standardmäßig enthält dies das System-GUI wie das Chatfenster. Sie müssen jetzt ein Skript in ReplicatedStorage erstellen, um den Upgrade-Button in die GUI jedes Spielers zu kopieren und das Verhalten zu implementieren, wenn der Button gedrückt wird.

Erstellen Sie JumpButtonClickHandler
Erstellen Sie in 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 falsch ist
		error(purchased)
	elseif success and not purchased then
		warn("Nicht genügend Münzen!")
	end
end

jumpButton.Activated:Connect(onButtonClicked)

-- Fügen Sie die JumpPurchaseGui zur GUI des Spielers hinzu
jumpPurchaseGui.Parent = playerGui
```

Code-Erklärung

Die folgenden Abschnitte beschreiben den Code im Detail.

Referenzen zur GUI und Serverfunktion erhalten - Die Variablen IncreaseJumpPowerFunction, jumpPurchaseGui und jumpButton enthalten Referenzen zu der Funktion und der GUI, die die Funktion aufruft, die Sie später benötigen werden.
Definieren Sie den Ereignis-Handler - onButtonClicked() definiert die Logik für den Fall, dass Benutzer auf den Upgrade-Button klicken. Es verwendet pcall() (geschützte Anruf) um die RemoteFunction aufzurufen. Jede Client-Server-Kommunikation wie diese erfordert pcall(), um Fehler oder Verbindungsprobleme zu handhaben.
Verbinden Sie 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.

Testen

Wählen Sie Test aus dem Dropdown-Menü und klicken Sie auf Spielen. Der Upgrade Jump-Button erscheint in der unteren rechten Ecke.

Versuchen Sie den Button zu klicken, bevor Sie Münzen sammeln, um zu überprüfen, dass Ihnen keine zusätzliche Sprungkraft verliehen wird, und versuchen Sie dann, einige Münzen zu sammeln und sehen Sie, ob das Upgrade funktioniert, wenn Sie erneut klicken.

Da der Code vollständig ist, versuchen Sie, die Schwierigkeit anzupassen: fügen Sie Münzen hinzu, wenn das Tempo zu langsam erscheint, oder entfernen Sie einige und verstecken Sie sie an kniffligeren Orten, wenn Upgrades zu leicht kommen.