Tutorial · Sistemi di gioco

Come fare un negozio in Roblox Studio

Un negozio in un gioco Roblox sono due compiti: una GUI che mostra gli oggetti e uno script server che decide se l'acquisto avviene. In questa guida costruiamo entrambi per un negozio a monete che vende strumenti, e mostriamo dove vanno gli acquisti in Robux.

Aggiornato il 20 novembre 202614 min di letturaScritto da

In breve

Tieni oggetti e prezzi in un ModuleScript in ReplicatedStorage, costruisci la finestra con ScreenGui, ScrollingFrame e UIGridLayout, e fai in modo che ogni pulsante Buy chiami una RemoteFunction passando solo l'id dell'oggetto. Poi uno Script in ServerScriptService trova da solo il prezzo, controlla e scala le Coins del giocatore e consegna l'oggetto.

  • Non lasciare mai che il client invii il prezzo. Chiunque può chiamare i tuoi remote con qualsiasi valore, quindi il server prende il prezzo dalla propria copia del catalogo.
  • Consegna il Tool acquistato clonandolo da ServerStorage nel Backpack del giocatore (per usarlo subito) e in StarterGear (perché torni dopo il respawn).
  • Quello che si vende per Robux sono pass e developer product, gestiti da MarketplaceService. Per questi Roblox crea anche da solo uno Shop, che non è la stessa cosa di un negozio a monete.
In questa pagina
  1. Come è fatto
  2. 1. Preparazione
  3. 2. Catalogo degli oggetti
  4. 3. GUI del negozio
  5. 4. Acquisti sul server
  6. Perché niente prezzo dal client
  7. 5. Prova
  8. Game pass
  9. Salvare gli acquisti
  10. Common errors
  11. Con RoCode
  12. Domande frequenti
  13. Fonti e letture

Come è fatto un negozio che funziona

IllustrazioneIl giocatore apre il negozio e compra Flashlight per 25 monete: le Coins scendono da 200 a 175, il pulsante diventa Owned e lo strumento compare nella hotbar.

Un negozio che funziona in un gioco vero è diviso tra il dispositivo del giocatore e il server. Il dispositivo disegna la finestra e dice "voglio comprare la spada". Il server, l'unica parte di cui ci si può fidare, decide se succede. Gli script dei negozi che "non funzionano" o che i giocatori rompono con i cheat spesso prendono questa decisione dalla parte sbagliata.

Le cinque parti del negozio
ParteDove si trovaCosa fa
ModuleScript ShopCatalogReplicatedStorageId degli oggetti, nomi, prezzi e il Tool che dà ognuno. Lo leggono entrambe le parti.
RemoteFunction BuyItemReplicatedStorage, nella cartella ShopRemotesPorta la richiesta di acquisto al server e la risposta indietro.
LocalScript ShopClientStarterPlayerScriptsCostruisce la finestra del negozio e invia l'id dell'oggetto quando viene premuto un pulsante Buy.
Script ShopServiceServerScriptServiceControlla la richiesta, scala le Coins e consegna il Tool.
I Tool che vendiServerStorage, nella cartella ShopItemsGli originali che il server copia. Niente di ServerStorage viene inviato ai giocatori.
L'Explorer quando il negozio è pronto
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

Passo 1: monete e oggetti in vendita

Il negozio spende il valore Coins nelle leaderstats del giocatore. Se hai seguito la guida alla classifica, ce l'hai già e puoi saltare questo script. Altrimenti inserisci uno Script in ServerScriptService chiamato Leaderstats. Dà a tutti 200 monete all'inizio, così puoi provare subito gli acquisti.

Script in ServerScriptService chiamato Leaderstats
local Players = game:GetService("Players")

local STARTING_COINS = 200 -- bastano per provare il negozio; metti 0 quando i giocatori potranno guadagnare monete

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

Tieni un solo script leaderstats. Due script che creano ognuno una cartella leaderstats danno a ogni giocatore due cartelle, e il negozio può leggere quella sbagliata.

Poi crea gli oggetti che cercano gli script. Maiuscole e minuscole nei nomi contano, quindi scrivili esattamente come qui.

  1. Nell'Explorer passa il mouse su ReplicatedStorage, clicca il pulsante + e inserisci una Folder chiamata ShopRemotes. Al suo interno inserisci una RemoteFunction chiamata BuyItem.
  2. Passa il mouse su ServerStorage e inserisci una Folder chiamata ShopItems.
  3. Metti in ShopItems un Tool per ogni oggetto, con i nomi ClassicSword, Flashlight, GrappleHook e SpeedCoil. Per la prima prova basta che il Tool contenga una sola Part non ancorata chiamata Handle. Va bene anche qualsiasi Tool che hai già: dagli il nome giusto. Le armi che fanno davvero danno costruiscile con la guida alla spada o la guida alla pistola (in inglese); in ognuna c'è scritto come collegarla al catalogo.
  4. Seleziona ogni Tool e togli la spunta da CanBeDropped nella finestra Properties. Quando è spuntata, premere Backspace lascia cadere lo strumento in Workspace, e qualsiasi giocatore può raccogliere quello che l'acquirente ha pagato.

Puoi iniziare anche con un solo Tool. Se manca il Tool di un oggetto, il server si rifiuta di vendere quell'oggetto e scrive un avviso con il suo nome, quindi al giocatore non viene scalato nulla.

Passo 2: oggetti e prezzi nel catalogo

Il catalogo è l'unica lista di tutto quello che vende il negozio. Il LocalScript lo legge per disegnare le schede, e il server lo legge per trovare i prezzi, quindi cambiare un prezzo è una sola modifica in un solo posto.

Passa il mouse su ReplicatedStorage, inserisci un ModuleScript, rinominalo ShopCatalog e sostituisci il contenuto con questo:

ModuleScript in ReplicatedStorage chiamato ShopCatalog
export type ShopItem = {
	id: string, -- poi viene salvato nell'archivio dati: non cambiarlo quando i giocatori hanno già l'oggetto
	name: string, -- mostrato sulla scheda; si può cambiare
	price: number, -- in Coins
	description: string,
	toolName: string, -- il Tool in ServerStorage.ShopItems che riceve il giocatore
}

-- Le schede compaiono in questo ordine
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

-- Restituisce l'oggetto con questo id, oppure nil se non esiste
function ShopCatalog.get(id: string): ShopItem?
	return byId[id]
end

-- L'attributo del Player che il server imposta a true quando il giocatore possiede l'oggetto
function ShopCatalog.ownedAttribute(id: string): string
	return "Owns_" .. id
end

return ShopCatalog

Ogni oggetto ha un id e, separato, un name da mostrare. Il server registra proprio l'id quando il giocatore possiede qualcosa, quindi "Classic Sword" si può rinominare più avanti senza rompere gli acquisti salvati. Le descrizioni sono solo testo sulla scheda; cosa fa il Tool lo decidono i suoi script.

I giocatori possono leggere un ModuleScript in ReplicatedStorage, quindi questi prezzi sono pubblici. Va bene: sono comunque scritti sulle schede. Quello che conta è che client e server eseguono ognuno la propria copia del modulo, quindi un giocatore che cambia i prezzi sul suo dispositivo non cambia nulla sul server.

Passo 3: costruiamo la GUI del negozio

Questo LocalScript costruisce tutta la finestra nel codice: il pulsante Shop, un pannello con una griglia di schede scorrevole, un pulsante Buy per ogni oggetto del catalogo, il contatore delle Coins e una riga di stato per le risposte del server. Siccome è tutto fatto in codice, puoi incollarlo e premere Play. La tabella dopo lo script elenca ogni oggetto, se vuoi comporre la finestra a mano.

  1. Nell'Explorer apri StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato ShopClient.
  2. Sostituisci il suo contenuto con il codice qui sotto.
LocalScript in StarterPlayerScripts chiamato ShopClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Cosa restituisce il modulo ShopCatalog, così il controllo dei tipi strict verifica i campi che usiamo
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: contiene tutto quello che il negozio disegna sullo schermo del giocatore
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- il negozio resta quando il personaggio fa respawn

-- Il pulsante sul bordo sinistro che apre e chiude il negozio
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 finestra del negozio: al centro, nascosta finché il giocatore non la apre
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) -- impedisce alla finestra di diventare enorme sugli schermi grandi
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

-- Qui compaiono le risposte del server, per esempio "You need 20 more coins."
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: l'area che scorre quando le schede sono più di quelle che ci stanno
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() -- parte da zero; AutomaticCanvasSize lo allarga per le schede
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel

-- UIGridLayout: dispone le schede in righe e le porta a capo nella riga successiva
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..."

		-- Inviamo solo l'id dell'oggetto. Il prezzo lo trova il server da solo.
		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)

	-- Il server imposta questo attributo quando l'acquisto è andato a buon fine (o quando sono stati caricati gli oggetti salvati)
	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")

-- Mostriamo le monete del giocatore. Il valore vero ce l'ha il server; qui viene solo mostrato.
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()

I pulsanti usano Activated, non MouseButton1Click: scatta con il clic del mouse, con il tocco sul telefono e con il pulsante A o la croce sul gamepad.

Le definizioni type in alto descrivono cosa restituisce ShopCatalog, così il controllo dei tipi strict trova un errore di battitura in un campo, per esempio item.prise. Quando il gioco è in esecuzione non cambiano nulla.

Oggetti della GUI e proprietà importanti
OggettoCompito nel negozioProprietà principali
ScreenGuiContiene tutto quello che è disegnato sullo schermoResetOnSpawn false, così il negozio sopravvive al respawn
FrameLa finestra e ogni scheda oggettoAnchorPoint 0.5, 0.5 e Position 0.5, 0.5, così la finestra è al centro
UISizeConstraintLimita la finestra sugli schermi grandiMaxSize 640 per 460
ScrollingFrameScorre quando le schede sono più di quelle che ci stannoCanvasSize 0 e AutomaticCanvasSize Y, così l'area di scorrimento cresce con le schede
UIGridLayoutMette le schede in righe e le porta a capoCellSize 180 per 200, CellPadding 12, SortOrder LayoutOrder
UICornerArrotonda gli angoliCornerRadius da 8 a 14 pixel
UIPaddingMargini interniDa 10 a 12 pixel per lato
TextButtonI pulsanti Shop, chiudi e BuyL'evento Activated

Se vuoi disegnare la finestra a mano, costruisci gli stessi oggetti in StarterGui con queste proprietà, anche lì imposta ResetOnSpawn della ScreenGui a false e lascia una scheda come modello che il LocalScript clona per ogni oggetto del catalogo. A quel punto lo script si limita a riempire le schede e collegare i pulsanti. La logica di acquisto del passo successivo non cambia.

Se il tuo gioco inizia con un menu principale, in quella guida c'è una riga da aggiungere a ShopClient perché il pulsante Shop compaia solo dopo che il giocatore ha premuto Play. Per aprire il negozio parlando con un venditore, la guida ai dialoghi degli NPC mostra come aggiungere un'azione OpenShop che dice a ShopClient di aprire la finestra, mentre gli acquisti passano sempre dai controlli server del negozio.

Passo 4: controllo e acquisto sul server

Questo Script è l'unico posto in cui può avvenire un acquisto. Riceve l'id dell'oggetto, lo controlla, trova il prezzo, controlla le Coins del giocatore, poi scala le monete e consegna il Tool. Al pulsante Buy risponde con true o false e un messaggio da mostrare.

Passa il mouse su ServerScriptService, inserisci uno Script chiamato ShopService e incollaci questo:

Script in ServerScriptService chiamato ShopService
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Cosa restituisce il modulo ShopCatalog, così il controllo dei tipi strict verifica i campi che usiamo
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: il giocatore può usare lo strumento subito
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack then
		template:Clone().Parent = backpack
	end
	-- StarterGear: Roblox lo ricopia nel Backpack ogni volta che compare il personaggio
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		template:Clone().Parent = starterGear
	end
end

local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
	-- 1. Il client invia solo l'id dell'oggetto, quindi deve essere una stringa
	if type(itemId) ~= "string" then
		return false, "That item does not exist."
	end

	-- 2. Ignoriamo i doppi clic e le raffiche di richieste da 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. Cerchiamo l'oggetto nella copia del catalogo del server
	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. Il prezzo viene dal catalogo e mai dal client
	if coins.Value < item.price then
		return false, `You need {item.price - coins.Value} more coins.`
	end

	-- 5. Scaliamo le monete, poi consegniamo l'oggetto. Qui niente sospende l'esecuzione, quindi due richieste
	-- dello stesso giocatore non possono superare entrambe i controlli sopra prima che questo sia eseguito.
	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)

Il possesso è salvato come attributo del Player, per esempio Owns_sword. Gli attributi impostati dal server si replicano sul dispositivo del giocatore, quindi il LocalScript può far passare la scheda a "Owned". Una modifica che il giocatore fa sulla sua copia non arriva al server.

Il Tool finisce in due posti. La copia nel Backpack compare subito nella hotbar. La copia in StarterGear Roblox la mette nel nuovo Backpack ogni volta che compare il personaggio. Senza, l'oggetto acquistato sparirebbe alla prima morte del giocatore.

Perché il client non invia mai il prezzo

Tutto quello che si trova sul dispositivo del giocatore, quel giocatore può modificarlo. I cheater eseguono il proprio codice nella loro copia del gioco: possono leggere i tuoi LocalScript, cambiare la GUI e chiamare BuyItem:InvokeServer() con qualsiasi argomento tutte le volte che vogliono. La guida di Roblox alla sicurezza dice di controllare sia il tipo sia il valore di tutto quello che riceve un remote, e come esempio usa proprio un negozio.

Cosa succede se il server si fida del client
Il cheater inviaSe il server gli credesseCosa fa ShopService
Un prezzo di 0Tutti gli oggetti sono gratisLo ignora. Il prezzo viene dal catalogo.
Un prezzo di -1000Coins.Value -= -1000 gli dà 1.000 moneteLo ignora.
NaN come prezzoOgni confronto con NaN è falso, quindi il controllo "monete insufficienti" non scatta maiLo ignora.
Un id che non è nel catalogo, o una tabella invece di una stringaErrori nello script o oggetti che non volevi vendereRisponde "That item does not exist."
Centinaia di richieste al secondoCarico sul server, e ogni buco nei controlli scatta centinaia di volteGestisce al massimo una richiesta per giocatore ogni mezzo secondo.
Coins modificate sul proprio schermoAcquisti con monete che non haNon lo vede proprio. Il server legge solo il proprio valore di Coins.

Questa regola vale per ogni remote che scrivi: invia quello che il giocatore ha scelto, per esempio l'id di un oggetto o il numero di uno slot, e mai quanto costa o cosa deve ricevere. La guida ai RemoteEvent approfondisce il controllo degli argomenti dei remote.

Passo 5: proviamo il negozio

  1. Premi Play. A sinistra compare il pulsante Shop. Aprilo e compra Flashlight: le Coins scendono di 25, lo strumento compare nella hotbar e il suo pulsante diventa Owned.
  2. Prova Speed Coil, che costa 300. La riga di stato dice quante monete mancano ancora, e non viene scalato nulla.
  3. Resetta il personaggio dal menu di gioco. Flashlight torna nel nuovo Backpack grazie alla copia in StarterGear.
  4. Per darti più monete durante la prova, clicca l'interruttore Client/Server e passa a Server, trova nell'Explorer Players, il tuo nome, leaderstats, Coins e cambia il suo Value nella finestra Properties. La stessa cosa in modalità Client cambia solo il tuo schermo, ed è proprio il tipo di modifica che il server ignora.

Se il pulsante risponde "The shop did not answer", apri la finestra Output dal menu Window di Studio e cerca un errore rosso di ShopService. Se invece il pulsante resta su "Buying...", ShopService non è in esecuzione o è bloccato in attesa di un oggetto: guarda gli errori frequenti.

Vendere un game pass per Robux

Le monete sono la tua valuta, quindi il negozio qui sopra decide da solo ogni acquisto. Quello che il giocatore compra in Robux funziona diversamente: un game pass si compra una volta e resta per sempre (bonus VIP, uno strumento permanente), mentre un developer product si può comprare più e più volte (un pacchetto di monete, saltare un livello). Entrambi passano da MarketplaceService di Roblox, e il pagamento lo riceve Roblox, non il tuo script.

Da questa guida si portano dietro due regole: avvia la finestra di acquisto con un pulsante sul client, e consegna il bonus solo sul server, quando Roblox ha confermato l'acquisto o il giocatore possiede già il pass. La guida allo script dei game pass (in inglese) costruisce tutto: il controllo del possesso all'ingresso, la finestra di acquisto, bonus come una porta VIP e quando conviene un developer product invece di un pass. Per scegliere il prezzo, il calcolatore della commissione Robux gratuito mostra quanto ti rende un pass o un developer product dopo la quota di Roblox.

Salvare gli acquisti dei giocatori

Tutto quello che abbiamo fatto dura una sessione: monete e oggetti acquistati si azzerano quando il giocatore esce, finché non li salvi con l'archivio dati. Per non ripetere qui il codice di salvataggio, segui il tutorial sui DataStore (o il passo 3 della guida alla classifica, che ha una versione più breve) e ricorda le regole del negozio:

  • Salva gli id degli oggetti, per esempio { "sword", "flashlight" }, nella stessa tabella del valore Coins, così un solo salvataggio registra sia le monete spese sia l'oggetto acquistato. Tool e altre istanze non si possono mettere nell'archivio dati.
  • Quando i dati sono caricati, scorri gli id salvati, salta quelli che non sono più nel catalogo, imposta ogni attributo Owns_ e consegna il Tool come fa giveTool. La finestra del negozio si aggiorna da sola, perché ascolta questi attributi.
  • Il possesso di un pass non va salvato: UserOwnsGamePassAsync chiede a Roblox ogni volta che il giocatore entra.
  • Non salvare mai un giocatore i cui dati non sono stati caricati, altrimenti un caricamento fallito può sostituire i suoi acquisti con una lista vuota.

Errori comuni e soluzioni

Quando il negozio si comporta in modo strano, controlla prima questo. Come prima cosa apri la finestra Output (menu Window, poi Output): un errore di script indica lo script e la riga.

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

Lo script aspetta un oggetto che non esiste con quel nome esatto. Controlla grafia e maiuscole di ShopRemotes, BuyItem, ShopCatalog e ShopItems, e che ShopItems sia in ServerStorage e non in ReplicatedStorage. La guida agli errori degli script spiega questo avviso nel dettaglio.

Il pulsante Buy resta su "Buying..." e non risponde

Sul server nessuno ha impostato BuyItem.OnServerInvoke, quindi Roblox tiene ferma la richiesta finché non succede. Assicurati che ShopService sia uno Script, non un LocalScript, e che stia in ServerScriptService, e cerca nell'Output un avviso Infinite yield possible di ShopService: significa che lo script è bloccato in attesa di ShopCatalog, ShopRemotes o ShopItems.

Il pulsante Buy scrive "The shop did not answer"

La chiamata al server è fallita invece di restituire una risposta. Il motivo tipico è un errore dentro ShopService durante la gestione della richiesta, quindi cerca nell'Output un errore rosso di ShopService: indica la riga.

Il pulsante scrive "This item is not available right now"

Il server non ha trovato un Tool con il toolName di quell'oggetto dentro ServerStorage, ShopItems. Nell'Output c'è un avviso con il nome esatto che cercava.

Ho comprato lo strumento, ma il personaggio non riesce a tenerlo o si blocca

Il Tool deve avere esattamente una parte chiamata Handle direttamente al suo interno, e nessuna delle sue parti deve essere ancorata. Per uno strumento che non va tenuto in mano, togli invece la spunta da RequiresHandle.

Le monete sono diminuite sul mio schermo, ma non per gli altri

L'acquisto è avvenuto in un LocalScript, quindi è cambiato solo il tuo dispositivo. Sposta lo scalo delle monete e la consegna del Tool in uno Script server, come nel passo 4.

Gli oggetti acquistati spariscono dopo essere rientrato

Per ora non si salva nulla. Guarda salvare gli acquisti.

Farlo con RoCode

Se non hai voglia di costruire tutto questo a mano, RoCode può farlo nel place che hai aperto. È un agente IA indipendente per il codice: descrivi la funzione nella sua chat web, e il suo plugin per Roblox Studio crea gli script, il remote e la GUI nel tuo Explorer, quindi non devi copiare codice da una finestra di chat.

Tu scrivi

Aggiungi un negozio a monete: un pulsante Shop che apre una griglia di quattro strumenti con prezzi in Coins dalle mie leaderstats. Il server deve controllare il prezzo e consegnare lo strumento nel Backpack e in StarterGear.

RoCode fa
  • Può esaminare il tuo place con Search Scripts e Read Script per cercare leaderstats e codice del negozio già presenti, così usa il tuo valore Coins invece di aggiungerne un secondo
  • Può costruire una bozza della finestra con Build UI: il layout del negozio arriva con schede segnaposto e un LocalScript per gli effetti al passaggio del mouse e il pulsante Close; la logica di acquisto viene scritta in script separati
  • Crea la RemoteFunction con Create Instance e scrive il ModuleScript del catalogo, lo Script server e il LocalScript con Create Script
  • Controlla che ogni script compili in Studio con Check Script (non controlla i tipi e non esegue gli script), e ogni gruppo di modifiche è un punto di annullamento in Studio

I pass devi comunque crearli tu nel Creator Hub, perché RoCode non sa creare pass e developer product, e anche gli acquisti li provi tu: con il plugin 3.9 o più recente RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.15 o più recente il suo personaggio di prova può premere i pulsanti Shop e Buy, ma controlla solo quello che ha deciso di provare. Di solito il negozio arriva dopo il gameplay principale e il salvataggio; il ciclo passo per passo per creare un gioco con RoCode mostra dove va. Come RoCode si collega a Studio.

Domande frequenti

Per un pulsante Buy su Roblox è meglio un RemoteEvent o una RemoteFunction?

Vanno bene entrambi, se a controllare è il server. Una RemoteFunction permette al pulsante di aspettare la risposta del server e mostrarla, per questo la guida la usa, e anche nella guida di Roblox alla sicurezza l'esempio del negozio usa una RemoteFunction. Chiamala solo dal client: un server che chiama InvokeClient può restare in attesa per sempre se il client non risponde mai. La guida ai RemoteEvent confronta le due opzioni.

Come apro il negozio tramite un NPC invece che con un pulsante?

Metti un ProximityPrompt in una parte dell'NPC, per esempio nella sua HumanoidRootPart, ascolta il suo evento Triggered in uno Script server e invia a quel giocatore un RemoteEvent perché il LocalScript mostri il pannello. Se si può comprare solo vicino all'NPC, controlla anche la distanza dall'NPC dentro il gestore di BuyItem, perché il client può chiamare il remote da qualsiasi punto.

Come vendo oggetti che si possono comprare più volte?

Per questi oggetti salta il controllo "già posseduto" e invece di un Tool consegna qualcosa che si può contare, per esempio aggiungi 1 a un IntValue che conta le pozioni. La ricerca del prezzo e il controllo delle monete lasciali come sono.

Perché il negozio sparisce quando il personaggio fa respawn?

La sua ScreenGui ha ResetOnSpawn a true, che è il valore predefinito, quindi Roblox la elimina al respawn. Mettilo a false, come fa lo script del passo 3.

Posso usare un template gratuito di GUI del negozio?

Sì, va bene qualsiasi layout, purché i suoi pulsanti Buy inviino solo l'id dell'oggetto e l'acquisto vero avvenga in uno Script server come ShopService. Prima di usare un template, controlla che non scali le monete o consegni oggetti in un LocalScript.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.