Script un pulsante di aggiornamento | Documentazione

I giocatori possono ora raccogliere monete e perderle quando muoiono, ma le monete non fanno nulla, e la maggior parte del mondo 3D è inaccessibile senza la capacità di saltare molto in alto. Questa sezione del tutorial ti insegna a completare la logica della tua esperienza aggiungendo un pulsante sullo schermo che spende monete per aumentare il potere di salto.

Crea il pulsante di aggiornamento

Le interfacce 2D in Roblox sono tipicamente composte da una raccolta di componenti GUI all'interno di un contenitore GUI. In questo caso, hai bisogno solo di un componente TextButton che dice Aggiorna Salto (5 Monete) all'interno di un contenitore ScreenGui.

Imposta la GUI di aggiornamento
In ReplicatedStorage, crea una cartella chiamata Instances.

Dentro la cartella Instances, crea uno ScreenGui chiamato JumpPurchaseGui con ResetOnSpawn disabilitato.

Dentro JumpPurchaseGui, crea un TextButton chiamato JumpButton con le seguenti proprietà:
- Text: "Aggiorna Salto (5 Monete)"
- TextSize: 25
- AnchorPoint: 1, 1
- Position: {1, 0}, {1, 0}

Inoltre, all'interno della cartella Instances, crea una RemoteFunction chiamata IncreaseJumpPowerFunction.

Infine, nel servizio StarterPlayer, abilita la proprietà CharacterUseJumpPower.

Definisci i dati di potenza di salto

Attualmente, solo il conteggio delle monete è memorizzato per ogni giocatore nello script del modulo PlayerData. Devi anche memorizzare e aggiornare il potere di salto allo stesso modo. Poiché le funzioni in PlayerData non sono specifiche per i dati da modificare, è sufficiente aggiungere una chiave Jump e inizializzare il suo valore iniziale in defaultPlayerData().

Aggiorna PlayerData con potenza di salto
In ServerStorage, sostituisci il codice esistente dello script PlayerData ModuleScript con il seguente:

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

Aggiorna i dati di potenza di salto

Ora che PlayerData è in grado di tenere traccia del potere di salto, devi implementare la logica sul server per aggiornare il potere di salto dalla richiesta del client di un giocatore.

Il server e il client possono comunicare tramite RemoteEvents o RemoteFunctions. Gli eventi remoti non si fermano quando vengono attivati e possono essere usati per la comunicazione unidirezionale. Le funzioni remote, d'altra parte, si fermano fino a quando non ricevono una risposta, il che consente una comunicazione bidirezionale.

Per questo tutorial, il client deve sapere se il server ha aggiornato con successo il potere di salto del giocatore, quindi dovresti utilizzare una funzione remota.

Crea JumpService
In ServerScriptService, crea uno Script chiamato JumpService con il seguente codice:

```lua
-- Servizi
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")

-- Moduli
local Leaderboard = require(ServerStorage.Leaderboard)
local PlayerData = require(ServerStorage.PlayerData)

-- Eventi
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)
	-- Aggiorna la tabella del potere di salto
	local newJumpPower = PlayerData.updateValue(player, JUMP_KEY_NAME, updateFunction)

	-- Aggiorna il potere di salto dei giocatori
	local character = player.Character or player.CharacterAdded:Wait()
	local humanoid = character:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		humanoid.JumpPower = newJumpPower

		-- Aggiorna la leaderboard del salto
		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

	-- Aumenta il potere di salto del giocatore
	updateJumpPower(player, function(oldJumpPower)
		oldJumpPower = oldJumpPower or 0
		return oldJumpPower + JUMP_POWER_INCREMENT
	end)
	-- Aggiorna la tabella delle monete
	local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, function(oldCoinAmount)
		return oldCoinAmount - JUMP_COIN_COST
	end)
	-- Aggiorna la leaderboard delle monete
	Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
	return true
end

local function onCharacterAdded(player)
	-- Resetta il potere di salto del giocatore quando il personaggio viene aggiunto
	updateJumpPower(player, function(_)
		return 0
	end)
end

-- Inizializza i giocatori aggiunti prima di connettersi all'evento PlayerAdded
for _, player in Players:GetPlayers() do
	onCharacterAdded(player)
end

-- Inizializzazione normale dei giocatori dall'evento PlayerAdded
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)
```

Spiegazione del codice

Le seguenti sezioni descrivono il codice in maggior dettaglio.

Aggiorna i dati di potenza di salto - updateJumpPower() aggiorna il potere di salto del giocatore e la leaderboard per fornire un feedback visivo. Questa funzione assomiglia al codice che danneggia i giocatori in Crea pericoli per i giocatori. Presupponendo che un modello di Character e Humanoid esista per il giocatore che viene aggiornato, la funzione aggiorna la proprietà JumpPower al nuovo valore memorizzato da PlayerData, aumentandolo di 30. Se vuoi che il tuo gioco duri leggermente più a lungo, puoi ridurre questo numero.
Valida le richieste del server - onPurchaseJumpIncrease() controlla innanzitutto che il giocatore abbia effettivamente il numero di monete richieste per acquistare l'aggiornamento. Tutte le richieste dai client al server devono essere validate per prevenire attori malintenzionati che inviano richieste false e sfruttano il tuo gioco.

Aggiungi il pulsante alla GUI del giocatore

Un oggetto ScreenGui viene visualizzato solo se è parentato all'oggetto PlayerGui di un giocatore. Per impostazione predefinita, questo contiene la GUI di sistema come la finestra della chat. Ora devi creare uno script in ReplicatedStorage per copiare il pulsante di aggiornamento nella GUI di ogni giocatore e implementare il comportamento per quando il pulsante viene premuto.

Crea JumpButtonClickHandler
In ReplicatedStorage, crea uno Script chiamato JumpButtonClickHandler con RunContext impostato su Client e il seguente codice:

```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 sarà il messaggio di errore se success è false
		error(purchased)
	elseif success and not purchased then
		warn("Non hai abbastanza monete!")
	end
end

jumpButton.Activated:Connect(onButtonClicked)

-- Aggiungi il JumpPurchaseGui alla GUI del giocatore
jumpPurchaseGui.Parent = playerGui
```

Spiegazione del codice

Le seguenti sezioni descrivono il codice in maggior dettaglio.

Ottieni riferimenti alla GUI e alla funzione del server - Le variabili IncreaseJumpPowerFunction, jumpPurchaseGui e jumpButton contengono riferimenti alla funzione e alla GUI che chiama la funzione di cui avrai bisogno in seguito.
Definisci il gestore dell'evento - onButtonClicked() definisce la logica per quando gli utenti cliccano sul pulsante di aggiornamento. Utilizza pcall() (chiamata protetta) per invocare il RemoteFunction. Qualsiasi comunicazione client-server come questa richiede pcall() per gestire errori o problemi di connessione.
Collega il gestore al pulsante - L'evento Activated è compatibile su tutte le piattaforme, inclusi mouse, touchscreen o contesti del gamepad. Viene attivato quando un clic, tocco o pulsante del gamepad viene rilasciato.

Prova di gioco

Seleziona Gioca dal menu a discesa e clicca su Play. Il pulsante Aggiorna Salto appare nell'angolo in basso a destra.

Prova a cliccare sul pulsante prima di raccogliere monete per controllare che non ti assegni ulteriore potere di salto, poi prova a raccogliere alcune monete e controlla se l'aggiornamento funziona quando clicchi di nuovo.

Con il codice completo, prova a regolare la difficoltà: aggiungi monete se il ritmo sembra lento, oppure rimuovine alcune e nascondile in posti più difficili se gli aggiornamenti arrivano troppo facilmente.