Tutoriel · Systèmes de jeu

Comment faire une boutique (shop GUI) sur Roblox Studio

Une boutique dans un jeu Roblox, c'est deux tâches : une interface (GUI) qui montre les objets, et un script serveur qui décide si un achat a lieu. Ce guide construit les deux pour une boutique en coins qui vend des outils, et montre où se placent les achats en Robux.

Mis à jour le 14 novembre 202615 min de lectureÉcrit par

En bref

Garde tes objets et leurs prix dans un ModuleScript dans ReplicatedStorage, construis la fenêtre avec un ScreenGui, un ScrollingFrame et un UIGridLayout, et fais que chaque bouton Buy appelle une RemoteFunction avec seulement l'id de l'objet. Un Script dans ServerScriptService cherche alors le prix lui-même, vérifie et retire les Coins du joueur, puis donne l'objet.

  • Ne laisse jamais le client envoyer le prix. N'importe qui peut appeler tes remotes avec n'importe quelles valeurs, donc le serveur lit le prix dans sa propre copie du catalogue.
  • Donne un Tool acheté en le clonant depuis ServerStorage dans le Backpack du joueur (pour s'en servir tout de suite) et dans son StarterGear (pour qu'il revienne après une réapparition).
  • Ce qui se vend en Robux, ce sont les pass et les developer products, gérés avec MarketplaceService. Roblox crée aussi une Shop automatique pour eux, qui est séparée d'une boutique en coins.
Sur cette page
  1. Fonctionnement
  2. 1. Préparation
  3. 2. Catalogue
  4. 3. Interface (GUI)
  5. 4. Achats côté serveur
  6. Pas de prix du client
  7. 5. Tester
  8. Game pass
  9. Sauvegarder les achats
  10. Problèmes courants
  11. Avec RoCode
  12. Questions fréquentes
  13. Sources et lectures

Comment les pièces d'une boutique s'assemblent

Illustration animéeLe joueur ouvre la boutique et achète la Flashlight pour 25 coins : les Coins passent de 200 à 175, son bouton devient Owned et l'outil apparaît dans la barre d'outils.

Une boutique qui marche dans un jeu en ligne est partagée entre l'appareil du joueur et le serveur. L'appareil dessine la fenêtre et dit "je veux acheter l'épée". Le serveur, le seul côté auquel tu peux faire confiance, décide si ça se fait. Les scripts de boutique qui "ne marchent pas", ou que les joueurs exploitent, prennent souvent cette décision du mauvais côté.

Les cinq pièces de la boutique
PièceOù elle se trouveCe qu'elle fait
ModuleScript ShopCatalogReplicatedStorageLes id, noms et prix des objets, et le Tool que donne chacun. Les deux côtés le lisent.
RemoteFunction BuyItemReplicatedStorage, dans un dossier nommé ShopRemotesPorte la demande d'achat au serveur et rapporte la réponse.
LocalScript ShopClientStarterPlayerScriptsConstruit la fenêtre de la boutique et envoie l'id de l'objet quand on appuie sur un bouton Buy.
Script ShopServiceServerScriptServiceVérifie la demande, retire les Coins et donne le Tool.
Les Tools que tu vendsServerStorage, dans un dossier nommé ShopItemsLes originaux que le serveur copie. Rien de ServerStorage n'est envoyé aux joueurs.
L'Explorer une fois la boutique terminée
ReplicatedStorage
  ShopCatalog ModuleScript new
  ShopRemotes Folder new
    BuyItem RemoteFunction new
ServerStorage
  ShopItems Folder new
    ClassicSword Tool new
      Handle Part
    Flashlight Tool new
    GrappleHook Tool new
    SpeedCoil Tool new
ServerScriptService
  Leaderstats Script
  ShopService Script new
StarterPlayer
  StarterPlayerScripts
    ShopClient LocalScript new

Étape 1 : préparer les coins et les objets à vendre

La boutique dépense une valeur Coins dans les leaderstats du joueur. Si tu as suivi le guide du leaderboard, tu en as déjà une, donc saute ce script. Sinon, insère un Script dans ServerScriptService nommé Leaderstats. Il donne 200 coins à tout le monde au départ pour que tu puisses tester les achats tout de suite.

Script dans ServerScriptService nommé Leaderstats
local Players = game:GetService("Players")

local STARTING_COINS = 200 -- assez pour tester la boutique ; mets 0 quand les joueurs pourront gagner des coins

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Value = STARTING_COINS
	coins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Garde un seul script leaderstats. Deux scripts qui créent chacun un dossier leaderstats donnent deux dossiers à chaque joueur, et la boutique risque de lire le mauvais.

Ensuite, crée les objets que les scripts cherchent. Les noms sont sensibles à la casse, donc tape-les exactement comme ci-dessous.

  1. Dans l'Explorer, survole ReplicatedStorage, clique sur le bouton + et insère un Folder nommé ShopRemotes. Dedans, insère une RemoteFunction nommée BuyItem.
  2. Survole ServerStorage et insère un Folder nommé ShopItems.
  3. Mets un Tool pour chaque objet dans ShopItems, nommés ClassicSword, Flashlight, GrappleHook et SpeedCoil. Pour un premier test, un Tool a seulement besoin d'une Part non ancrée nommée Handle à l'intérieur. N'importe quel Tool que tu as déjà marche aussi : donne-lui le nom correspondant. Pour une arme qui fait vraiment des dégâts, construis-en une avec le guide de l'épée ou le guide du pistolet (en anglais) ; chacun explique comment la faire correspondre au catalogue.
  4. Sélectionne chaque Tool et décoche CanBeDropped dans la fenêtre Properties. Quand c'est coché, appuyer sur Retour arrière fait tomber l'outil dans le Workspace, où n'importe quel joueur peut ramasser ce que l'acheteur a payé.

Tu peux commencer avec un seul Tool. Si le Tool d'un objet manque, le serveur refuse de vendre cet objet et affiche un avertissement qui le nomme, donc rien n'est retiré au joueur.

Étape 2 : mettre les objets et les prix dans un catalogue

Le catalogue est la liste unique de tout ce que vend la boutique. Le LocalScript le lit pour dessiner les cartes et le serveur le lit pour trouver les prix, donc changer un prix, c'est une seule modification à un seul endroit.

Survole ReplicatedStorage, insère un ModuleScript, renomme-le ShopCatalog et remplace son contenu par ceci :

ModuleScript dans ReplicatedStorage nommé ShopCatalog
export type ShopItem = {
	id: string, -- sauvegardé plus tard dans les data stores : ne le change jamais une fois que des joueurs possèdent l'objet
	name: string, -- affiché sur la carte ; tu peux le changer sans risque
	price: number, -- en Coins
	description: string,
	toolName: string, -- le Tool de ServerStorage.ShopItems que reçoit le joueur
}

-- Les cartes apparaissent dans cet ordre
local items: { ShopItem } = {
	{
		id = "sword",
		name = "Classic Sword",
		price = 50,
		description = "A basic sword for close fights.",
		toolName = "ClassicSword",
	},
	{
		id = "flashlight",
		name = "Flashlight",
		price = 25,
		description = "Lights up dark corners.",
		toolName = "Flashlight",
	},
	{
		id = "grapple",
		name = "Grapple Hook",
		price = 150,
		description = "Reach high ledges.",
		toolName = "GrappleHook",
	},
	{
		id = "speedcoil",
		name = "Speed Coil",
		price = 300,
		description = "Run faster while you hold it.",
		toolName = "SpeedCoil",
	},
}

local byId: { [string]: ShopItem } = {}
for _, item in items do
	byId[item.id] = item
end

local ShopCatalog = {}

ShopCatalog.items = items

-- Renvoie l'objet qui a cet id, ou nil s'il n'existe pas
function ShopCatalog.get(id: string): ShopItem?
	return byId[id]
end

-- L'attribut du Player que le serveur met à true quand le joueur possède un objet
function ShopCatalog.ownedAttribute(id: string): string
	return "Owns_" .. id
end

return ShopCatalog

Chaque objet a un id en plus du name affiché. L'id est ce que le serveur enregistre quand un joueur possède quelque chose, donc tu peux renommer "Classic Sword" plus tard sans casser les achats sauvegardés. Les descriptions ne sont que du texte sur la carte ; ce que fait un Tool dépend des scripts de ce Tool.

Les joueurs peuvent lire un ModuleScript dans ReplicatedStorage, donc ces prix sont publics. Ce n'est pas grave : ils sont affichés sur les cartes de toute façon. Ce qui compte, c'est que le client et le serveur exécutent chacun leur propre copie du module, donc un joueur qui modifie les prix sur son appareil ne change rien sur le serveur.

Étape 3 : construire l'interface de la boutique

Ce LocalScript construit toute la fenêtre en code : un bouton Shop, un panneau avec une grille de cartes qui défile, un bouton Buy par objet du catalogue, un compteur de Coins et une ligne d'état pour les réponses du serveur. Comme tout est en code, tu peux le coller et appuyer sur Play. Le tableau qui suit liste chaque objet si tu préfères disposer la fenêtre à la main.

  1. Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts et insère un LocalScript nommé ShopClient.
  2. Remplace son contenu par le code ci-dessous.
LocalScript dans StarterPlayerScripts nommé ShopClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Ce que renvoie le module ShopCatalog, pour que la vérification stricte des types contrôle les champs utilisés
type ShopItem = { id: string, name: string, price: number, description: string, toolName: string }
type Catalog = {
	items: { ShopItem },
	get: (id: string) -> ShopItem?,
	ownedAttribute: (id: string) -> string,
}

local ShopCatalog = require(ReplicatedStorage:WaitForChild("ShopCatalog")) :: Catalog
local buyItem = ReplicatedStorage:WaitForChild("ShopRemotes"):WaitForChild("BuyItem") :: RemoteFunction

local player = Players.LocalPlayer

local COLOURS = {
	panel = Color3.fromRGB(24, 20, 36),
	card = Color3.fromRGB(38, 32, 56),
	accent = Color3.fromRGB(124, 77, 255),
	owned = Color3.fromRGB(70, 66, 84),
	text = Color3.fromRGB(240, 238, 245),
	muted = Color3.fromRGB(170, 165, 185),
	good = Color3.fromRGB(120, 220, 150),
}
local REGULAR = Font.fromEnum(Enum.Font.BuilderSans)
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)

local function addCorner(parent: GuiObject, radius: number)
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, radius)
	corner.Parent = parent
end

local function addPadding(parent: GuiObject, pixels: number)
	local padding = Instance.new("UIPadding")
	padding.PaddingTop = UDim.new(0, pixels)
	padding.PaddingBottom = UDim.new(0, pixels)
	padding.PaddingLeft = UDim.new(0, pixels)
	padding.PaddingRight = UDim.new(0, pixels)
	padding.Parent = parent
end

local function newLabel(parent: GuiObject, text: string, textSize: number, font: Font): TextLabel
	local label = Instance.new("TextLabel")
	label.BackgroundTransparency = 1
	label.Text = text
	label.TextSize = textSize
	label.FontFace = font
	label.TextColor3 = COLOURS.text
	label.TextXAlignment = Enum.TextXAlignment.Left
	label.TextWrapped = true
	label.Parent = parent
	return label
end

local function newButton(parent: GuiObject, text: string): TextButton
	local button = Instance.new("TextButton")
	button.BackgroundColor3 = COLOURS.accent
	button.TextColor3 = COLOURS.text
	button.FontFace = BOLD
	button.TextSize = 18
	button.Text = text
	button.Parent = parent
	addCorner(button, 8)
	return button
end

-- ScreenGui : contient tout ce que la boutique dessine sur l'écran du joueur
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- garde la boutique quand le personnage réapparaît

-- Un bouton sur le bord gauche qui ouvre et ferme la boutique
local openButton = Instance.new("TextButton")
openButton.Name = "OpenShop"
openButton.AnchorPoint = Vector2.new(0, 0.5)
openButton.Position = UDim2.new(0, 16, 0.5, 0)
openButton.Size = UDim2.fromOffset(110, 44)
openButton.BackgroundColor3 = COLOURS.accent
openButton.TextColor3 = COLOURS.text
openButton.FontFace = BOLD
openButton.TextSize = 20
openButton.Text = "Shop"
openButton.Parent = gui
addCorner(openButton, 10)

-- La fenêtre de la boutique : centrée, cachée jusqu'à ce que le joueur l'ouvre
local panel = Instance.new("Frame")
panel.Name = "Panel"
panel.AnchorPoint = Vector2.new(0.5, 0.5)
panel.Position = UDim2.fromScale(0.5, 0.5)
panel.Size = UDim2.fromScale(0.8, 0.75)
panel.BackgroundColor3 = COLOURS.panel
panel.Visible = false
panel.Parent = gui
addCorner(panel, 14)
addPadding(panel, 12)

local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(640, 460) -- empêche la fenêtre de devenir énorme sur les grands écrans
sizeLimit.Parent = panel

local title = newLabel(panel, "Shop", 26, BOLD)
title.Size = UDim2.new(0.5, 0, 0, 32)

local coinsLabel = newLabel(panel, "Coins: ...", 20, BOLD)
coinsLabel.AnchorPoint = Vector2.new(1, 0)
coinsLabel.Position = UDim2.new(1, -44, 0, 0)
coinsLabel.Size = UDim2.new(0.5, -44, 0, 32)
coinsLabel.TextXAlignment = Enum.TextXAlignment.Right

local closeButton = newButton(panel, "X")
closeButton.AnchorPoint = Vector2.new(1, 0)
closeButton.Position = UDim2.fromScale(1, 0)
closeButton.Size = UDim2.fromOffset(32, 32)
closeButton.BackgroundColor3 = COLOURS.card

-- Les réponses du serveur, comme "You need 20 more coins.", s'affichent ici
local status = newLabel(panel, "", 18, REGULAR)
status.AnchorPoint = Vector2.new(0, 1)
status.Position = UDim2.fromScale(0, 1)
status.Size = UDim2.new(1, 0, 0, 24)
status.TextColor3 = COLOURS.muted

-- ScrollingFrame : la zone qui défile quand il y a plus de cartes que de place
local list = Instance.new("ScrollingFrame")
list.Name = "Items"
list.Position = UDim2.fromOffset(0, 44)
list.Size = UDim2.new(1, 0, 1, -76)
list.BackgroundTransparency = 1
list.BorderSizePixel = 0
list.ScrollBarThickness = 6
list.ScrollingDirection = Enum.ScrollingDirection.Y
list.CanvasSize = UDim2.new() -- commence à zéro ; AutomaticCanvasSize l'agrandit pour contenir les cartes
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel

-- UIGridLayout : range les cartes en lignes et passe à la ligne suivante
local grid = Instance.new("UIGridLayout")
grid.CellSize = UDim2.fromOffset(180, 200)
grid.CellPadding = UDim2.fromOffset(12, 12)
grid.SortOrder = Enum.SortOrder.LayoutOrder
grid.Parent = list

local function makeCard(item: ShopItem, order: number)
	local card = Instance.new("Frame")
	card.Name = item.id
	card.LayoutOrder = order
	card.BackgroundColor3 = COLOURS.card
	card.Parent = list
	addCorner(card, 10)
	addPadding(card, 10)

	local nameLabel = newLabel(card, item.name, 20, BOLD)
	nameLabel.Size = UDim2.new(1, 0, 0, 26)

	local description = newLabel(card, item.description, 15, REGULAR)
	description.Position = UDim2.fromOffset(0, 30)
	description.Size = UDim2.new(1, 0, 1, -80)
	description.TextColor3 = COLOURS.muted
	description.TextYAlignment = Enum.TextYAlignment.Top

	local buyButton = newButton(card, "")
	buyButton.Name = "Buy"
	buyButton.AnchorPoint = Vector2.new(0, 1)
	buyButton.Position = UDim2.fromScale(0, 1)
	buyButton.Size = UDim2.new(1, 0, 0, 40)

	local ownedAttribute = ShopCatalog.ownedAttribute(item.id)
	local busy = false

	local function refresh()
		if player:GetAttribute(ownedAttribute) == true then
			buyButton.Text = "Owned"
			buyButton.BackgroundColor3 = COLOURS.owned
			buyButton.AutoButtonColor = false
		else
			buyButton.Text = `Buy: {item.price} coins`
			buyButton.BackgroundColor3 = COLOURS.accent
			buyButton.AutoButtonColor = true
		end
	end

	buyButton.Activated:Connect(function()
		if busy or player:GetAttribute(ownedAttribute) == true then
			return
		end
		busy = true
		buyButton.Text = "Buying..."

		-- N'envoie que l'id de l'objet. Le serveur cherche le prix lui-même.
		local ok, bought, message = pcall(function()
			return buyItem:InvokeServer(item.id)
		end)
		if ok and type(message) == "string" then
			status.Text = message
			status.TextColor3 = if bought == true then COLOURS.good else COLOURS.muted
		else
			status.Text = "The shop did not answer. Try again."
			status.TextColor3 = COLOURS.muted
		end

		busy = false
		refresh()
	end)

	-- Le serveur règle cet attribut quand l'achat passe (ou quand les objets sauvegardés se chargent)
	player:GetAttributeChangedSignal(ownedAttribute):Connect(refresh)
	refresh()
end

for index, item in ShopCatalog.items do
	makeCard(item, index)
end

openButton.Activated:Connect(function()
	panel.Visible = not panel.Visible
	status.Text = ""
end)

closeButton.Activated:Connect(function()
	panel.Visible = false
end)

gui.Parent = player:WaitForChild("PlayerGui")

-- Affiche les coins du joueur. Le serveur détient la vraie valeur ; ceci ne fait que l'afficher.
local leaderstats = player:WaitForChild("leaderstats")
local coins = leaderstats:WaitForChild("Coins") :: IntValue
local function updateCoins()
	coinsLabel.Text = `Coins: {coins.Value}`
end
coins.Changed:Connect(updateCoins)
updateCoins()

Les boutons utilisent Activated plutôt que MouseButton1Click : il se déclenche pour un clic de souris, un appui sur un téléphone et le bouton A ou croix d'une manette.

Les définitions type en haut décrivent ce que renvoie ShopCatalog, pour que la vérification stricte des types repère un champ mal écrit comme item.prise. Elles ne changent rien quand le jeu tourne.

Les objets de l'interface et les propriétés qui comptent
ObjetRôle dans la boutiquePropriétés clés
ScreenGuiContient tout ce qui est dessiné à l'écranResetOnSpawn à false, pour que la boutique survive à une réapparition
FrameLa fenêtre, et chaque carte d'objetAnchorPoint 0.5, 0.5 et Position 0.5, 0.5 pour centrer la fenêtre
UISizeConstraintLimite la fenêtre sur les grands écransMaxSize 640 sur 460
ScrollingFrameDéfile quand il y a plus de cartes que de placeCanvasSize à 0 et AutomaticCanvasSize sur Y, pour que la zone de défilement grandisse avec les cartes
UIGridLayoutPlace les cartes en lignes et passe à la ligneCellSize 180 sur 200, CellPadding 12, SortOrder LayoutOrder
UICornerArrondit les coinsCornerRadius de 8 à 14 pixels
UIPaddingMarge intérieure10 à 12 pixels de chaque côté
TextButtonLes boutons Shop, fermer et BuyL'événement Activated

Pour dessiner la fenêtre à la main à la place, construis les mêmes objets sous StarterGui avec ces propriétés, règle là aussi ResetOnSpawn du ScreenGui sur false, et garde une carte comme modèle que le LocalScript clone pour chaque objet du catalogue. Le script se contente alors de remplir les cartes et de connecter les boutons. La logique d'achat de l'étape suivante ne change pas.

Si ton jeu s'ouvre sur un menu principal, ce guide donne la ligne à ajouter à ShopClient pour que le bouton Shop n'apparaisse qu'après que le joueur a appuyé sur Play. Pour ouvrir la boutique en parlant à un marchand, le guide des dialogues de PNJ montre comment ajouter une action OpenShop qui dit à ShopClient d'ouvrir sa fenêtre, pendant que les achats passent toujours par les vérifications serveur de la boutique.

Étape 4 : vérifier et valider les achats sur le serveur

Ce Script est le seul endroit où un achat peut se faire. Il reçoit l'id de l'objet, le vérifie, cherche le prix, vérifie les Coins du joueur, puis retire les coins et donne le Tool. Il répond au bouton Buy avec true ou false et un message à afficher.

Survole ServerScriptService, insère un Script nommé ShopService et colle ceci :

Script dans ServerScriptService nommé ShopService
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Ce que renvoie le module ShopCatalog, pour que la vérification stricte des types contrôle les champs utilisés
type ShopItem = { id: string, name: string, price: number, description: string, toolName: string }
type Catalog = {
	items: { ShopItem },
	get: (id: string) -> ShopItem?,
	ownedAttribute: (id: string) -> string,
}

local ShopCatalog = require(ReplicatedStorage:WaitForChild("ShopCatalog")) :: Catalog
local buyItem = ReplicatedStorage:WaitForChild("ShopRemotes"):WaitForChild("BuyItem") :: RemoteFunction
local shopItems = ServerStorage:WaitForChild("ShopItems")

local COOLDOWN_SECONDS = 0.5
local lastRequest: { [Player]: number } = {}

local function giveTool(player: Player, template: Tool)
	-- Backpack : le joueur peut utiliser l'outil tout de suite
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack then
		template:Clone().Parent = backpack
	end
	-- StarterGear : Roblox le recopie dans le Backpack à chaque apparition du personnage
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		template:Clone().Parent = starterGear
	end
end

local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
	-- 1. Le client n'envoie qu'un id d'objet, donc ce doit être une string
	if type(itemId) ~= "string" then
		return false, "That item does not exist."
	end

	-- 2. Ignore les doubles clics et les avalanches de requêtes envoyées par script
	local now = os.clock()
	local last = lastRequest[player]
	if last and now - last < COOLDOWN_SECONDS then
		return false, "Slow down a little."
	end
	lastRequest[player] = now

	-- 3. Cherche l'objet dans la copie du catalogue du serveur
	local item = ShopCatalog.get(itemId)
	if not item then
		return false, "That item does not exist."
	end

	local ownedAttribute = ShopCatalog.ownedAttribute(item.id)
	if player:GetAttribute(ownedAttribute) == true then
		return false, "You already own this."
	end

	local template = shopItems:FindFirstChild(item.toolName)
	if not (template and template:IsA("Tool")) then
		warn(`ShopItems has no Tool named {item.toolName} for shop item {item.id}`)
		return false, "This item is not available right now."
	end

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if not (coins and coins:IsA("IntValue")) then
		return false, "Your coins have not loaded yet."
	end

	-- 4. Le prix vient du catalogue, jamais du client
	if coins.Value < item.price then
		return false, `You need {item.price - coins.Value} more coins.`
	end

	-- 5. Retire les coins, puis donne l'objet. Rien ici ne fait de yield, donc deux requêtes
	-- du même joueur ne peuvent pas passer toutes les deux les vérifications ci-dessus avant ce code.
	coins.Value -= item.price
	giveTool(player, template)
	player:SetAttribute(ownedAttribute, true)

	return true, `You bought {item.name}.`
end

buyItem.OnServerInvoke = onBuyItem

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)

La possession est stockée comme un attribut du Player, comme Owns_sword. Les attributs que règle le serveur sont répliqués sur l'appareil du joueur, donc le LocalScript peut passer cette carte sur "Owned". Un changement qu'un joueur fait sur sa propre copie n'atteint jamais le serveur.

Le Tool va à deux endroits. La copie dans le Backpack apparaît tout de suite dans la barre d'outils. La copie dans StarterGear est ce que Roblox met dans le nouveau Backpack à chaque apparition du personnage. Sans elle, un objet acheté disparaît la première fois que le joueur meurt.

Pourquoi le client n'envoie jamais le prix

Tout ce qui est sur l'appareil d'un joueur peut être modifié par ce joueur. Les exploiteurs exécutent leur propre code dans leur copie du jeu : ils peuvent lire tes LocalScripts, modifier l'interface et appeler BuyItem:InvokeServer() avec n'importe quels arguments, aussi souvent qu'ils veulent. Le guide de sécurité de Roblox dit de vérifier à la fois le type et la valeur de tout ce que reçoit un remote, et il prend une boutique comme exemple.

Ce qui se passe si le serveur fait confiance au client
Un exploiteur envoieSi le serveur le croyaitCe que fait ShopService
Un prix de 0Tous les objets sont gratuitsL'ignore. Le prix vient du catalogue.
Un prix de -1000Coins.Value -= -1000 lui donne 1 000 coinsL'ignore.
NaN comme prixToute comparaison avec NaN est fausse, donc une vérification "pas assez de coins" ne se déclenche jamaisL'ignore.
Un id absent du catalogue, ou une table au lieu d'une stringDes erreurs de script, ou des objets que tu ne voulais pas vendreRépond "That item does not exist."
Des centaines de requêtes par secondeDe la charge sur le serveur, et la moindre faille dans tes vérifications est touchée des centaines de foisTraite au plus une requête par joueur toutes les demi-secondes.
Des Coins modifiés sur son propre écranDes achats avec des coins qu'il n'a pasNe le voit jamais. Le serveur ne lit que sa propre valeur Coins.

La règle vaut pour chaque remote que tu écris : envoie ce que le joueur a choisi, comme un id d'objet ou un numéro d'emplacement, jamais ce que ça coûte ni ce qu'il doit recevoir. Le guide des RemoteEvents va plus loin sur la validation des arguments des remotes.

Étape 5 : tester la boutique

  1. Appuie sur Play. Un bouton Shop apparaît à gauche. Ouvre-le et achète la Flashlight : tes Coins baissent de 25, l'outil apparaît dans ta barre d'outils et son bouton passe sur Owned.
  2. Essaie le Speed Coil, qui coûte 300. La ligne d'état indique combien de coins il te manque, et rien n'est retiré.
  3. Réinitialise ton personnage depuis le menu du jeu. La Flashlight revient dans le nouveau Backpack, grâce à la copie dans StarterGear.
  4. Pour te donner plus de coins pendant les tests, clique sur le bouton Client/Server pour passer sur Server, trouve Players, ton nom, leaderstats, Coins dans l'Explorer et change sa Value dans la fenêtre Properties. Faire la même chose en mode Client ne change que ton écran, et c'est exactement le genre de changement que le serveur ignore.

Si un bouton répond "The shop did not answer", ouvre la fenêtre Output depuis le menu Window de Studio et cherche une erreur rouge venant de ShopService. Si un bouton reste plutôt bloqué sur "Buying...", ShopService ne tourne pas ou attend un objet : voir Problèmes courants.

Vendre un game pass contre des Robux

Les coins sont ta propre monnaie, donc la boutique ci-dessus décide elle-même de chaque achat. Ce qu'un joueur achète en Robux marche autrement : un game pass s'achète une fois et se garde (avantages VIP, un outil permanent), et un developer product peut s'acheter encore et encore (un pack de coins, un skip). Les deux passent par MarketplaceService de Roblox, et c'est Roblox, pas ton script, qui encaisse le paiement.

Deux règles de ce guide restent valables : affiche la demande d'achat depuis un bouton côté client, et donne l'avantage seulement sur le serveur, une fois que Roblox confirme l'achat ou que le joueur possède déjà le pass. Le guide du script de game pass Roblox (en anglais) construit tout ça de bout en bout, avec la vérification de possession à l'arrivée, la demande d'achat, des avantages comme une porte VIP, et quand utiliser plutôt un developer product. Pour choisir un prix, le calculateur de taxe Robux (en anglais) gratuit montre ce qu'un pass ou un developer product te rapporte après la part de Roblox.

Sauvegarder ce que les joueurs ont acheté

Tout ce qu'on a fait jusqu'ici dure une session : les coins et les objets possédés repartent à zéro quand le joueur quitte, jusqu'à ce que tu les sauvegardes avec un data store. Plutôt que de répéter le code de sauvegarde ici, suis le tutoriel DataStore (ou l'étape 3 du guide du leaderboard pour une version plus courte) et garde en tête ces règles de boutique :

  • Sauvegarde les id des objets, comme { "sword", "flashlight" }, dans la même table que la valeur Coins, pour qu'une seule sauvegarde enregistre à la fois les coins dépensés et l'objet acheté. Les Tools et les autres instances ne peuvent pas être stockés dans un data store.
  • Quand les données se chargent, parcours les id sauvegardés, saute ceux que le catalogue n'a plus, règle chaque attribut Owns_ et donne le Tool de la même façon que giveTool. La fenêtre de la boutique se met à jour toute seule, parce qu'elle écoute ces attributs.
  • La possession d'un pass n'a pas besoin d'être sauvegardée : UserOwnsGamePassAsync demande à Roblox à chaque fois que le joueur arrive.
  • Ne sauvegarde jamais un joueur dont les données n'ont pas pu se charger, sinon un chargement raté peut remplacer ses achats par une liste vide.

Problèmes courants

Quand la boutique se comporte mal, vérifie d'abord ces points. Ouvre la fenêtre Output (menu Window, puis Output) avant tout : une erreur de script indique le script et la ligne.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'

Un script attend un objet qui n'existe pas sous ce nom exact. Vérifie l'orthographe et les majuscules de ShopRemotes, BuyItem, ShopCatalog et ShopItems, et que ShopItems est dans ServerStorage, pas dans ReplicatedStorage. Le guide des erreurs de script explique cet avertissement en détail.

Un bouton Buy reste sur "Buying..." et ne répond jamais

Rien sur le serveur n'a réglé BuyItem.OnServerInvoke, donc Roblox garde la demande en attente jusqu'à ce que quelque chose le fasse. Vérifie que ShopService est un Script, pas un LocalScript, dans ServerScriptService, et cherche dans Output un avertissement Infinite yield possible venant de ShopService : il veut dire que le script attend ShopCatalog, ShopRemotes ou ShopItems.

Un bouton Buy affiche "The shop did not answer"

L'appel au serveur a échoué au lieu de renvoyer une réponse. La cause habituelle est une erreur dans ShopService pendant qu'il traitait la demande, donc cherche une erreur rouge venant de ShopService dans Output : elle indique la ligne.

Un bouton affiche "This item is not available right now"

Le serveur n'a pas trouvé de Tool avec le toolName de cet objet dans ServerStorage, ShopItems. Output affiche un avertissement avec le nom exact qu'il cherchait.

J'ai acheté un outil mais mon personnage ne peut pas le tenir, ou reste bloqué

Un Tool a besoin d'exactement une part nommée Handle comme enfant direct, et aucune de ses parts ne doit être ancrée. Pour un outil sans rien à tenir, décoche plutôt RequiresHandle.

Mes coins ont baissé sur mon écran mais pas pour les autres

L'achat s'est fait dans un LocalScript, donc seul ton appareil a changé. Déplace le retrait des coins et le don du Tool dans un Script serveur, comme à l'étape 4.

Les objets achetés ont disparu quand je reviens dans le jeu

Rien n'est encore sauvegardé. Voir Sauvegarder ce que les joueurs ont acheté.

Le faire avec RoCode

Si tu préfères ne pas tout brancher à la main, RoCode peut le construire dans le jeu que tu as ouvert. C'est un agent IA de code indépendant : tu décris la fonctionnalité dans son chat web, et son plugin pour Roblox Studio crée les scripts, le remote et l'interface dans ton Explorer, donc tu ne copies pas de code depuis une fenêtre de chat.

Tu écris

Ajoute une boutique en coins : un bouton Shop qui ouvre une grille de quatre outils dont le prix est en Coins de mes leaderstats. Le serveur doit vérifier le prix et donner l'outil dans le Backpack et le StarterGear.

RoCode fait
  • Peut parcourir ton jeu à la recherche de leaderstats et de code de boutique existants avec Search Scripts et Read Script, pour réutiliser ta valeur Coins au lieu d'en ajouter une deuxième
  • Peut monter la fenêtre avec Build UI, dont la mise en page de boutique vient avec des cartes d'objets d'exemple et un LocalScript pour les effets de survol et le bouton Close ; la logique d'achat est écrite dans des scripts séparés
  • Crée la RemoteFunction avec Create Instance, et écrit le ModuleScript du catalogue, le Script serveur et le LocalScript avec Create Script
  • Vérifie la compilation de chaque script dans Studio avec Check Script (il ne vérifie pas les types et ne les lance pas), et chaque lot de changements est un point d'annulation dans Studio

Tu crées toujours toi-même les pass dans le Creator Hub, puisque RoCode ne peut pas créer de pass ni de developer products, et c'est toi qui testes les achats en jouant : avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.15 ou plus récent son personnage de test peut cliquer sur les boutons Shop et Buy, mais il ne vérifie que ce qu'il a choisi de tester. Une boutique vient en général après la boucle de jeu principale et la sauvegarde ; les étapes pour construire un jeu avec RoCode montrent où elle se place. Comment RoCode se connecte à Studio.

Questions fréquentes

Le bouton Buy doit-il utiliser un RemoteEvent ou une RemoteFunction ?

Les deux marchent, tant que c'est le serveur qui vérifie. Une RemoteFunction permet au bouton d'attendre la réponse du serveur et de l'afficher, c'est pourquoi ce guide en utilise une, et le guide de sécurité de Roblox utilise aussi une RemoteFunction pour son exemple de boutique. Appelle-la seulement depuis le client : un serveur qui appelle InvokeClient peut attendre indéfiniment si le client ne répond jamais. Le guide des RemoteEvents compare les deux.

Comment ouvrir la boutique depuis un PNJ plutôt qu'un bouton ?

Mets un ProximityPrompt dans une part du PNJ, comme son HumanoidRootPart, écoute son événement Triggered dans un Script serveur, et envoie un RemoteEvent à ce joueur pour que le LocalScript affiche le panneau. Si l'achat ne doit marcher que près du PNJ, vérifie aussi la distance au PNJ dans le gestionnaire de BuyItem, parce qu'un client peut appeler le remote de n'importe où.

Comment vendre des objets qu'on peut acheter plusieurs fois ?

Saute la vérification "déjà possédé" pour ces objets et donne quelque chose de comptable au lieu d'un Tool, par exemple ajoute 1 à une IntValue qui compte les potions. Garde la recherche du prix et la vérification des coins exactement comme elles sont.

Pourquoi ma boutique disparaît quand mon personnage réapparaît ?

Son ScreenGui a ResetOnSpawn à true, la valeur par défaut, donc Roblox le supprime à la réapparition. Mets-le à false, comme le fait le script de l'étape 3.

Est-ce que je peux utiliser un modèle de shop GUI gratuit ?

Oui, n'importe quelle mise en page marche, tant que ses boutons Buy n'envoient qu'un id d'objet et que l'achat lui-même se fait dans un Script serveur comme ShopService. Avant d'utiliser un modèle, vérifie dans ses scripts si des coins sont retirés ou des objets donnés dans un LocalScript.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.