Scripten Sie einen Upgrade-Button | Dokumentation

Spieler können jetzt Münzen sammeln und sie verlieren, wenn sie sterben, aber die Münzen tun nichts, und die meiste Spielwelt ist für diejenigen, die nicht übermäßig hoch springen können, nicht zugänglich. Dieser Abschnitt des Tutorials zeigt dir, wie du die Logik für deine Erfahrung abschließt, indem du einen On-Screen-Button hinzufügst, der Münzen ausgibt, um die Sprungkraft zu erhöhen.

Erstellen Sie die Upgrade-Schaltfläche

2D-Schnittstellen in Roblox bestehen normalerweise aus einer Reihe von GUI-Komponenten in einem GUI-Container. In diesem Fall benötigen Sie nur ein TextButton -Komponente, die sagt, Upgrade Jump (5 Coins) in einem ScreenGui-Container.

Um die grafische Benutzeroberflächezu erstellen:

In dem Explorer-Fenster , fügen Sie einen neuen Ordner in ReplicatedStorage hinzu, und benennen Sie den Ordner dann in Instances um. Jedes Objekt in 1> ReplicatedStorage1> ist für jeden Spieler:inzugänglich, wo GUIs angezeigt werden.
Fügen Sie ein ScreenGUI-Objekt in den Instanzen-Ordner hinzu.
Wählen Sie das ScreenGUI-Objekt und dann im Eigenschaften-Fenster 1. Set Name zu JumpPurchaseGui . 2. Deaktivieren Sie ResetOnSpawn , um sicherzustellen, dass die GUI beim Respawn dem Spieler zugewiesen bleibt.
In dem Explorer-Fenster , fügen Sie einen TextButton in den JumpPurchaseGui-Container ein, und benennen Sie dann den Text-Button in 1> JumpButton 1> um.
(Optional) Konfigurieren Sie die Aussehen und Positionen der Schaltfläche, indem Sie ihre Eigenschaften konfigurieren. Einfache Vorschläge umfassen:
- Setzen Sie die Text-Eigenschaft auf Upgrade Jump (5 Coins) .
- Setzen Sie die TextSize Eigenschaft auf 25 .
- Set AnchorPoint to 1, 1 and Position to 1, 0,1, 0 to move the button to the bottom right corner.

Du wirst den Button der GUI des Spieler:inspäter in diesem Tutorial hinzufügen, aber bevor du es tust, musst du alle die Logik und Daten definieren, die für die Schaltfläche erforderlich sind.

Definieren Sie Sprungkraft-Daten

Derzeit werden nur die Münzen-Anzahl für jeden Spieler im PlayerData Skript, das. PL: die Skriptsgespeichert. Sie müssen auch den Sprungkraft-Update-Power in derselben Weise speichern und aktualisieren. Da die Funktionen in PlayerData nicht spezifisch für die veränderten Daten sind, alles, was benötigt wird, um den Sprungkraft-Wert zu speichern, ist,

Um das PlayerData Modul-Skript zu aktualisieren, um Sprungkraft zu speichern:

Im Explorer-Fenster öffnen Sie das Modul PlayerData in ServerStorage .

Ersetzen Sie den Code in dem Skript durch die folgende Ansammlung, die einen Jump-Wert für jeden Spieler neben ihrem bestehenden Coins-Wert initialisiert:


local PlayerData = {}

PlayerData.COIN_KEY_NAME = "Coins"
PlayerData.JUMP_KEY_NAME = "Jump"

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

local DEFAULT_PLAYER_DATA = {
	[PlayerData.COIN_KEY_NAME] = 0,
	[PlayerData.JUMP_KEY_NAME] = 0,
}

local function getData(player)
	local data = playerData[tostring(player.UserId)] or DEFAULT_PLAYER_DATA
	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

Jump Power-Daten aktualisieren

Jetzt, da PlayerData die Sprungkraft verfolgen kann, musst du Logik auf dem Server implementieren, um die Sprungkraft von einem Spieler:inClient-Anfrage zu aktualisieren.

Der Server und der Client können über entweder Remote-Ereignisse oder Remote-Funktionen kommunizieren. Remote-Ereignisse geben nicht aus, wenn sie ausgeführt werden, und sind für eine einseitige Kommunikation geeignet. Remote-Funktionen geben aus, bis sie eine Antwort erhalten, was für eine zweiseitige Kommunikation ideal ist. In diesem Fall muss der Client wissen, ob der Server die Sprungkraft des Spieler:inerfolgreich aktualisiert hat, damit eine

Um das Sprung-Upgrade zu implementieren:

In dem Explorer-Fenster öffnen Sie den Instanzen-Ordner in ReplicatedStorage .
Fügen Sie einen RemoteFunction in den Instanzen -Ordner ein, und benennen Sie die Remote-Funktion dann in 1> ErhöhenJumpPowerFunction1> um. Sie erstellen immer Remote-Funktionen in 4> ReplicatedStorage 4>, da sowohl der Client als auch der Server auf sie zugreifen können.
In dem Explorer-Fenster wählen Sie StarterPlayer .
Im Eigenschaften -Fenster aktivieren Sie die CharakterUseJumpPower -Eigenschaft. Standardmäßig definiert der Charakter-Sprungkraftwert nicht die Menge, die ein Charakter springt, so dass dies aktiviert werden muss.
In dem Explorer-Fenster , fügen Sie ein neues Skript in ServerScriptService ein und benennen Sie das Skript dann in JumpService um. Dieses Skript enthält die Logik für Upgrades auf Sprung.

Ersetzen Sie den Standardcode durch den folgenden Codes:


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

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

		-- Aktualisieren Sie die Sprung-Bestenliste
		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 Sie die Sprungkraft des Spieler:in
	updateJumpPower(player, function(oldJumpPower)
		oldJumpPower = oldJumpPower or 0
		return oldJumpPower + JUMP_POWER_INCREMENT
	end)
	-- Aktualisieren Sie den Münztisch
	local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, function(oldCoinAmount)
		return oldCoinAmount - JUMP_COIN_COST
	end)
	-- Aktualisieren Sie die Münzen-Bestenliste
	Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
	return true
end

local function onCharacterAdded(player)
	-- Setzen Sie die Sprungkraft des Spieler:inzurück, wenn der Charakter hinzugefügt wird
	updateJumpPower(player, function(_)
		return 0
	end)
end

-- Initialisieren Sie alle Spieler, die vor dem Verbinden mit PlayerAdded hinzugefügt wurden
for _, player in Players:GetPlayers() do
	onCharacterAdded(player)
end

-- Normale Initialisierung von Spielern aus dem SpielerHinzugefügten-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)

Code-Erkl?rung

Die folgenden Abschnitte beschreiben den Code in mehreren Detail.

Aktualisieren Sie die Sprungkraft-Daten - updateJumpPower() aktualisiert die Sprungkraft des Spielers
Überprüfen Sie Serveranfragen validieren - onPurchaseJumpIncrease() первые Prüfungen, dass der Spieler die erforderliche Anzahl von Münzen hat, um das Upgrade zu kaufen. Alle Anfragen von Clients zum Server sollten 0> überprüft0> sein, um falsche Anforderungen zu verhindern und Ihr Erlebnis zu nutzen.

Füge den Button zum grafische Benutzeroberfläche

Ein ScreenGui-Objekt zeigt nur auf dem Bildschirm an, wenn es mit dem Objekt PlayerGui eines Spieler:inverbunden ist. Standardmäßig enthält dies das System-GUI, wie das Chat-Fenster. Du musst jetzt ein Skript in ReplicatedStorage erstellen, um den Upgrade-Button in der GUI jedes Spieler:inzu kopieren und das Verhalten zu implementieren, wenn er gedrückt wird.

Um dem Spieler die Schaltfläche hinzuzufügen, wenn er dem Spiel beitritt:

Im Explorer-Fenster erstellen Sie ein Skript in ReplicatedStorage .
Wähle das Skript, das. PL: die Skriptsund dann im Eigenschaften-Fenster ,
1. Set Name zu JumpButtonClickHandler .
2. Setzen Sie RunContext auf Client . Dies sagt dem Engine, dass der Client dieses Skript immer auf dem Client ausführen soll, um die Netzwerkkommunikation zu optimieren.

Im offenen Skript, das. PL: die Skriptsersetzen Sie den Standardcode durch den folgenden Codes:


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
		-- der kauf wird das fehler-message sein, wenn der erfolg falsch ist
		error(purchased)
	elseif success and not purchased then
		warn("Not enough coins!")
	end
end

jumpButton.Activated:Connect(onButtonClicked)

-- Füge die JumpPurchaseGui zum GUI des Spieler:inhinzu
jumpPurchaseGui.Parent = playerGui

Code-Erkl?rung

Die folgenden Abschnitte beschreiben den Code in mehreren Detail.

Erhalten Sie Referenzen auf die GUI und Server-Funktion - Die Variablen IncreaseJumpPowerFunction , jumpPurchaseGui und 0> jumpButton0> enthalten Referenzen auf die Funktion und GUI, die die Funktion bietet, die Sie später benötigen.
definieren Sie den Ereignishändler - onButtonClicked() definiert Logik für den Fall, wenn Benutzer auf die Schaltfläche Upgrade klicken. Es verwendet pcall() (geschützte Aufrufe), um den 0> Class.RemoteFunction0> zu verwalten. J
Verbinden Sie den Handler mit der Schaltfläche - Das Activated -Ereignis ist auf allen Plattformen, einschließlich der Maus, des Touch-Bildschirms oder des Gamepad-Kontexts, kompatibel. Es wird ausgelöst, wenn ein Klick , 0> Berührung 0> oder 3> Gamepad-Button 3> freigesetzt wird.

Spieltest

Du solltest jetzt in der Lage sein, Sprung-Upgrades für Münzen mit dem Upgrade-Button zu kaufen. Um das Projekt zu testen:

In der Menüleiste klicken Sie auf die Schaltfläche Spielen . Studio betritt den Spieltest-Modus.
Wenn deine Skripte richtig funktionieren, erscheint ein Kauf-Button auf dem Bildschirm. Versuche, den Button zu klicken, bevor du Münzen sammelst, um zu überprüfen, dass es dir keine zusätzliche Sprungkraft gewährt, dann versuche, einige Münzen zu sammeln und sieh, ob das Upgrade funktioniert, wenn du erneut auf das Spiel klickst.

Jetzt, da der Code fertig ist, versuchen Sie, das Spiel durch die Menge und Positionen der Münzen auszubalancieren. Fügen Sie mehr Münzen hinzu, wenn das Spiel zu langsam fühlt sich, oder entziehen Sie Münzen und stellen Sie sie in herausfordernde Orte, wenn es sich zu schnell und einfach fühlt.