Script un bouton de mise à niveau | Documentation

Les joueurs peuvent maintenant collecter des pièces et les perdre lorsqu'ils meurent, mais les pièces ne font rien, et la plupart du monde 3D est inaccessible sans la capacité de sauter très haut. Cette section du tutoriel vous apprend à finaliser la logique de votre expérience en ajoutant un bouton à l'écran qui dépense des pièces pour augmenter la puissance de saut.

Créer le bouton de mise à niveau

Les interfaces 2D dans Roblox sont généralement constituées d'un ensemble de composants GUI dans un conteneur GUI. Dans ce cas, vous avez seulement besoin d'un composant TextButton qui dit Améliorer le saut (5 pièces) à l'intérieur d'un conteneur ScreenGui.

Configurer le GUI de mise à niveau
Dans ReplicatedStorage, créez un dossier nommé Instances.

À l'intérieur du dossier Instances, créez un ScreenGui nommé JumpPurchaseGui avec ResetOnSpawn désactivé.

À l'intérieur de JumpPurchaseGui, créez un TextButton nommé JumpButton avec les propriétés suivantes :
- Text: "Améliorer le saut (5 pièces)"
- TextSize: 25
- AnchorPoint: 1, 1
- Position: {1, 0}, {1, 0}

Aussi à l'intérieur du dossier Instances, créez un RemoteFunction nommé IncreaseJumpPowerFunction.

Enfin, sur le service StarterPlayer, activez la propriété CharacterUseJumpPower.

Définir les données de puissance de saut

Actuellement, seule la quantité de pièces est stockée pour chaque joueur dans le script de module PlayerData. Vous devez également stocker et mettre à jour la puissance de saut de la même manière. Comme les fonctions dans PlayerData ne sont pas spécifiques aux données modifiées, tout ce qui est nécessaire pour stocker la puissance de saut du joueur est d'ajouter une clé Jump et d'initialiser sa valeur initiale dans defaultPlayerData().

Mettre à jour PlayerData avec la puissance de saut
Dans ServerStorage, remplacez le code existant du module PlayerData par le suivant :

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

Mettre à jour les données de puissance de saut

Maintenant que PlayerData est capable de suivre la puissance de saut, vous devez implémenter la logique sur le serveur pour mettre à niveau la puissance de saut d'une requête du client.

Le serveur et le client peuvent communiquer via RemoteEvents ou RemoteFunctions. Les événements distants ne cèdent pas lorsqu'ils sont déclenchés et peuvent être utilisés pour une communication unidirectionnelle. Les fonctions distantes, en revanche, cèdent jusqu'à ce qu'elles reçoivent une réponse, ce qui permet une communication bidirectionnelle.

Pour ce tutoriel, le client doit savoir si le serveur a réussi à mettre à niveau la puissance de saut du joueur, donc vous devriez utiliser une fonction distante.

Créer JumpService
Dans ServerScriptService, créez un script nommé JumpService avec le code suivant :

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

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

-- Événements
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)
	-- Mettre à jour la table de puissance de saut
	local newJumpPower = PlayerData.updateValue(player, JUMP_KEY_NAME, updateFunction)

	-- Mettre à jour la puissance de saut du joueur
	local character = player.Character or player.CharacterAdded:Wait()
	local humanoid = character:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		humanoid.JumpPower = newJumpPower

		-- Mettre à jour le tableau des scores de saut
		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

	-- Augmenter la puissance de saut du joueur
	updateJumpPower(player, function(oldJumpPower)
		oldJumpPower = oldJumpPower or 0
		return oldJumpPower + JUMP_POWER_INCREMENT
	end)
	-- Mettre à jour le tableau des pièces
	local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, function(oldCoinAmount)
		return oldCoinAmount - JUMP_COIN_COST
	end)
	-- Mettre à jour le tableau des scores de pièces
	Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
	return true
end

local function onCharacterAdded(player)
	-- Réinitialiser la puissance de saut du joueur lorsque le personnage est ajouté
	updateJumpPower(player, function(_)
		return 0
	end)
end

-- Initialiser tous les joueurs ajoutés avant de se connecter à l'événement PlayerAdded
for _, player in Players:GetPlayers() do
	onCharacterAdded(player)
end

-- Initialisation normale des joueurs depuis l'événement 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)
```

Explication du code

Les sections suivantes décrivent le code plus en détail.

Mettre à jour les données de puissance de saut - updateJumpPower() met à jour la puissance de saut du joueur et le tableau des scores pour offrir un retour visuel. Cette fonction ressemble au code qui endommage des joueurs dans Créer des dangers pour les joueurs. Étant donné qu'un modèle Character et Humanoid existent pour le joueur amélioré, la fonction met à jour la propriété JumpPower avec la nouvelle valeur stockée par PlayerData, l'augmentant de 30. Si vous souhaitez que votre jeu dure légèrement plus longtemps, vous pouvez réduire ce nombre.
Valider les demandes du serveur - onPurchaseJumpIncrease() vérifie d'abord que le joueur a réellement le nombre de pièces requis pour acheter la mise à niveau. Toutes les demandes des clients au serveur doivent être validées pour empêcher des acteurs malveillants de soumettre de fausses demandes et d'exploiter votre jeu.

Ajouter le bouton à la GUI du joueur

Un objet ScreenGui n'est affiché à l'écran que s'il est parenté à l'objet PlayerGui d'un joueur. Par défaut, cela contient l'interface système comme la fenêtre de chat. Vous devez maintenant créer un script dans ReplicatedStorage pour copier le bouton de mise à niveau dans la GUI de chaque joueur et implémenter son comportement lorsqu'il est pressé.

Créer JumpButtonClickHandler
Dans ReplicatedStorage, créez un script nommé JumpButtonClickHandler avec RunContext défini sur Client et le code suivant :

```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 sera le message d'erreur si le succès est faux
		error(purchased)
	elseif success and not purchased then
		warn("Pas assez de pièces !")
	end
end

jumpButton.Activated:Connect(onButtonClicked)

-- Ajouter le JumpPurchaseGui à la GUI du joueur
jumpPurchaseGui.Parent = playerGui
```

Explication du code

Les sections suivantes décrivent le code plus en détail.

Obtenir des références au GUI et à la fonction serveur - Les variables IncreaseJumpPowerFunction, jumpPurchaseGui, et jumpButton contiennent des références à la fonction et au GUI qui appelle la fonction dont vous aurez besoin plus tard.
Définir le gestionnaire d'événements - onButtonClicked() définit la logique pour lorsque les utilisateurs cliquent sur le bouton de mise à niveau. Il utilise pcall() (appel protégé) pour invoquer la RemoteFunction. Toute communication client-serveur comme celle-ci nécessite pcall() pour gérer les erreurs ou les problèmes de connexion.
Connecter le gestionnaire au bouton - L'événement Activated est compatible sur toutes les plateformes, y compris la souris, l'écran tactile ou le contexte de la manette. Il se déclenche lorsqu'un clic, toucher, ou bouton de manette est relâché.

Tester le jeu

Sélectionnez Tester dans le menu déroulant et cliquez sur Jouer. Le bouton Améliorer le saut apparaît dans le coin inférieur droit.

Essayez de cliquer sur le bouton avant de collecter des pièces pour vérifier qu'il ne vous accorde pas de puissance de saut supplémentaire, puis essayez de collecter des pièces et voyez si la mise à niveau fonctionne lorsque vous cliquez à nouveau.

Avec le code complet, essayez de régler la difficulté : ajoutez des pièces si le rythme semble lent, ou enlevez-en quelques-unes et placez-les dans des endroits plus délicats si les mises à niveau sont trop faciles à obtenir.