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
Come è fatto un negozio che funziona
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.
| Parte | Dove si trova | Cosa fa |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | Id degli oggetti, nomi, prezzi e il Tool che dà ognuno. Lo leggono entrambe le parti. |
RemoteFunction BuyItem | ReplicatedStorage, nella cartella ShopRemotes | Porta la richiesta di acquisto al server e la risposta indietro. |
LocalScript ShopClient | StarterPlayerScripts | Costruisce la finestra del negozio e invia l'id dell'oggetto quando viene premuto un pulsante Buy. |
Script ShopService | ServerScriptService | Controlla la richiesta, scala le Coins e consegna il Tool. |
| I Tool che vendi | ServerStorage, nella cartella ShopItems | Gli originali che il server copia. Niente di ServerStorage viene inviato ai giocatori. |
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.
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.
- Nell'Explorer passa il mouse su ReplicatedStorage, clicca il pulsante + e inserisci una Folder chiamata
ShopRemotes. Al suo interno inserisci una RemoteFunction chiamataBuyItem. - Passa il mouse su ServerStorage e inserisci una Folder chiamata
ShopItems. - Metti in ShopItems un Tool per ogni oggetto, con i nomi
ClassicSword,Flashlight,GrappleHookeSpeedCoil. Per la prima prova basta che il Tool contenga una sola Part non ancorata chiamataHandle. 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. - 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:
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.
- Nell'Explorer apri StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato
ShopClient. - Sostituisci il suo contenuto con il codice qui sotto.
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.
| Oggetto | Compito nel negozio | Proprietà principali |
|---|---|---|
ScreenGui | Contiene tutto quello che è disegnato sullo schermo | ResetOnSpawn false, così il negozio sopravvive al respawn |
Frame | La finestra e ogni scheda oggetto | AnchorPoint 0.5, 0.5 e Position 0.5, 0.5, così la finestra è al centro |
UISizeConstraint | Limita la finestra sugli schermi grandi | MaxSize 640 per 460 |
ScrollingFrame | Scorre quando le schede sono più di quelle che ci stanno | CanvasSize 0 e AutomaticCanvasSize Y, così l'area di scorrimento cresce con le schede |
UIGridLayout | Mette le schede in righe e le porta a capo | CellSize 180 per 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Arrotonda gli angoli | CornerRadius da 8 a 14 pixel |
UIPadding | Margini interni | Da 10 a 12 pixel per lato |
TextButton | I pulsanti Shop, chiudi e Buy | L'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:
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.
| Il cheater invia | Se il server gli credesse | Cosa fa ShopService |
|---|---|---|
| Un prezzo di 0 | Tutti gli oggetti sono gratis | Lo ignora. Il prezzo viene dal catalogo. |
| Un prezzo di -1000 | Coins.Value -= -1000 gli dà 1.000 monete | Lo ignora. |
NaN come prezzo | Ogni confronto con NaN è falso, quindi il controllo "monete insufficienti" non scatta mai | Lo ignora. |
| Un id che non è nel catalogo, o una tabella invece di una stringa | Errori nello script o oggetti che non volevi vendere | Risponde "That item does not exist." |
| Centinaia di richieste al secondo | Carico sul server, e ogni buco nei controlli scatta centinaia di volte | Gestisce al massimo una richiesta per giocatore ogni mezzo secondo. |
| Coins modificate sul proprio schermo | Acquisti con monete che non ha | Non 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
- 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.
- Prova Speed Coil, che costa 300. La riga di stato dice quante monete mancano ancora, e non viene scalato nulla.
- Resetta il personaggio dal menu di gioco. Flashlight torna nel nuovo Backpack grazie alla copia in StarterGear.
- Per darti più monete durante la prova, clicca l'interruttore Client/Server e passa a Server, trova nell'Explorer
Players, il tuo nome,leaderstats,Coinse 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 fagiveTool. La finestra del negozio si aggiorna da sola, perché ascolta questi attributi. - Il possesso di un pass non va salvato:
UserOwnsGamePassAsyncchiede 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.
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.
- 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
- Roblox Creator Docs: Securing the client-server boundary (in inglese). controllo degli argomenti dei remote, NaN, limite di frequenza e l'esempio di un negozio di gioco
- Roblox Creator Docs: Remote events and callbacks (in inglese). RemoteFunction, InvokeServer, OnServerInvoke e i rischi di InvokeClient
- Roblox Creator Docs: Passes (in inglese). creare e vendere pass, UserOwnsGamePassAsync e PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (in inglese). lo Shop di gioco che Roblox crea automaticamente
- Roblox Creator Docs: Developer Products (in inglese). acquisti ripetibili in Robux e ProcessReceipt
- Roblox Creator Docs: StarterGear (in inglese). perché un Tool in StarterGear torna dopo il respawn
- Roblox Creator Docs: In-game tools (in inglese). Handle, ancoraggio e RequiresHandle
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.