Resumo
Guarde os itens e os preços em um ModuleScript no ReplicatedStorage, monte a janela com um ScreenGui, um ScrollingFrame e um UIGridLayout, e faça cada botão Buy chamar um RemoteFunction enviando só o id do item. Um Script no ServerScriptService então procura o preço por conta própria, confere e tira as Coins do jogador e entrega o item.
- Nunca deixe o cliente enviar o preço. Qualquer um pode chamar os seus remotes com qualquer valor, então o servidor lê o preço da própria cópia do catálogo.
- Entregue uma Tool comprada clonando ela do ServerStorage para a Backpack do jogador (para usar agora) e para o StarterGear (para ela voltar depois de um respawn).
- O que é vendido por Robux são passes e developer products, tratados com o MarketplaceService. A Roblox também cria uma Shop automática para eles, que é separada de uma loja de moedas.
Nesta página
Como as peças de uma loja funcionam juntas
Uma loja que funciona em um jogo publicado fica dividida entre o dispositivo do jogador e o servidor. O dispositivo desenha a janela e diz "quero comprar a espada". O servidor, o único lado em que dá para confiar, decide se isso acontece. Scripts de loja que "não funcionam", ou que os jogadores exploram, muitas vezes tomam essa decisão no lado errado.
| Peça | Onde fica | O que faz |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | Ids, nomes e preços dos itens e a Tool que cada um entrega. Os dois lados leem. |
RemoteFunction BuyItem | ReplicatedStorage, em uma pasta chamada ShopRemotes | Leva o pedido de compra para o servidor e traz a resposta de volta. |
LocalScript ShopClient | StarterPlayerScripts | Monta a janela da loja e envia o id do item quando um botão Buy é apertado. |
Script ShopService | ServerScriptService | Confere o pedido, tira as Coins e entrega a Tool. |
| As Tools que você vende | ServerStorage, em uma pasta chamada ShopItems | Os originais que o servidor copia. Nada no ServerStorage é enviado aos jogadores. |
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: Prepare as moedas e os itens para vender
A loja gasta um valor Coins nas leaderstats do jogador. Se você seguiu o guia de leaderboard, já tem um, então pule este script. Se não, insira um Script no ServerScriptService com o nome Leaderstats. Ele começa todo mundo com 200 moedas para você testar compras na hora.
local Players = game:GetService("Players")
local STARTING_COINS = 200 -- o bastante para testar a loja; coloque 0 quando os jogadores puderem ganhar moedas
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
Tenha só um script de leaderstats. Dois scripts que criam cada um uma pasta leaderstats dão duas pastas para todo jogador, e a loja pode ler a errada.
Depois, crie os objetos que os scripts procuram. Os nomes diferenciam maiúsculas de minúsculas, então digite exatamente como aparece aqui.
- No Explorer, passe o mouse sobre o ReplicatedStorage, clique no botão + e insira uma Folder chamada
ShopRemotes. Dentro dela, insira um RemoteFunction chamadoBuyItem. - Passe o mouse sobre o ServerStorage e insira uma Folder chamada
ShopItems. - Coloque uma Tool para cada item dentro de ShopItems, com os nomes
ClassicSword,Flashlight,GrappleHookeSpeedCoil. Para um primeiro teste, uma Tool só precisa de uma Part não ancorada chamadaHandledentro dela. Qualquer Tool que você já tenha também serve: dê a ela o nome certo. Para uma arma que causa dano de verdade, monte uma com o guia de espada ou o guia de arma (em inglês); cada um explica como ligar a arma ao catálogo. - Selecione cada Tool e desmarque CanBeDropped na janela Properties. Quando está marcado, apertar Backspace derruba a tool no Workspace, onde qualquer jogador pode pegar o que o comprador pagou.
Você pode começar com uma Tool só. Se a Tool de um item estiver faltando, o servidor se recusa a vender esse item e mostra um aviso com o nome dele, então nada é tirado do jogador.
Passo 2: Coloque os itens e os preços em um catálogo
O catálogo é a lista única de tudo o que a loja vende. O LocalScript lê o catálogo para desenhar os cards e o servidor lê para achar os preços, então mudar um preço é uma edição em um lugar só.
Passe o mouse sobre o ReplicatedStorage, insira um ModuleScript, renomeie para ShopCatalog e troque o conteúdo dele por isto:
export type ShopItem = {
id: string, -- depois fica salvo em data stores: nunca mude quando jogadores já tiverem o item
name: string, -- aparece no card; pode mudar sem problema
price: number, -- em Coins
description: string,
toolName: string, -- a Tool em ServerStorage.ShopItems que o jogador recebe
}
-- Os cards aparecem nesta ordem
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
-- Devolve o item com este id, ou nil se não existir esse item
function ShopCatalog.get(id: string): ShopItem?
return byId[id]
end
-- O atributo do Player que o servidor define como true quando o jogador tem um item
function ShopCatalog.ownedAttribute(id: string): string
return "Owns_" .. id
end
return ShopCatalog
Cada item tem um id além de um name de exibição. O id é o que o servidor registra quando um jogador tem algo, então você pode renomear "Classic Sword" depois sem quebrar compras salvas. As descrições são só texto no card; o que uma Tool faz depende dos scripts da própria Tool.
Os jogadores conseguem ler um ModuleScript no ReplicatedStorage, então esses preços são públicos. Tudo bem: eles já aparecem nos cards. O que importa é que o cliente e o servidor rodam cada um a sua própria cópia do módulo, então um jogador que edita os preços no próprio dispositivo não muda nada no servidor.
Passo 3: Monte a GUI da loja
Este LocalScript monta a janela inteira por código: um botão Shop, um painel com uma grade de cards com rolagem, um botão Buy por item do catálogo, um contador de Coins e uma linha de status para as respostas do servidor. Como é tudo código, você pode colar e apertar Play. A tabela depois dele lista cada objeto, caso você prefira montar a janela à mão.
- No Explorer, expanda o StarterPlayer, passe o mouse sobre o StarterPlayerScripts e insira um LocalScript chamado
ShopClient. - Troque o conteúdo dele pelo código abaixo.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- O que o módulo ShopCatalog devolve, para a checagem de tipos strict conferir os campos que usamos
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: guarda tudo o que a loja desenha na tela do jogador
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- mantém a loja quando o personagem dá respawn
-- Um botão na borda esquerda que abre e fecha a loja
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)
-- A janela da loja: centralizada, escondida até o jogador abrir
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) -- impede a janela de ficar enorme em telas grandes
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
-- As respostas do servidor, como "You need 20 more coins.", aparecem aqui
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: a área que rola quando há mais cards do que cabem
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() -- começa em zero; o AutomaticCanvasSize aumenta para caber os cards
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel
-- UIGridLayout: organiza os cards em linhas e passa para a próxima linha
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..."
-- Envie só o id do item. O servidor procura o preço por conta própria.
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)
-- O servidor define este atributo quando a compra dá certo (ou quando os itens salvos carregam)
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")
-- Mostra as moedas do jogador. O servidor é dono do valor real; isto só exibe.
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()
Os botões usam Activated em vez de MouseButton1Click: ele dispara com um clique do mouse, um toque no celular e o botão A ou X de um controle.
As definições de type no topo descrevem o que o ShopCatalog devolve, para a checagem de tipos strict pegar um campo escrito errado, como item.prise. Elas não mudam nada quando o jogo roda.
| Objeto | Papel na loja | Propriedades principais |
|---|---|---|
ScreenGui | Guarda tudo o que é desenhado na tela | ResetOnSpawn false, para a loja sobreviver a um respawn |
Frame | A janela e cada card de item | AnchorPoint 0.5, 0.5 e Position 0.5, 0.5 para centralizar a janela |
UISizeConstraint | Limita a janela em telas grandes | MaxSize 640 por 460 |
ScrollingFrame | Rola quando há mais cards do que cabem | CanvasSize 0 e AutomaticCanvasSize Y, para a área de rolagem crescer com os cards |
UIGridLayout | Coloca os cards em linhas e quebra para a próxima | CellSize 180 por 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Arredonda os cantos | CornerRadius de 8 a 14 pixels |
UIPadding | Espaço interno | 10 a 12 pixels de cada lado |
TextButton | Botões Shop, fechar e Buy | O evento Activated |
Para desenhar a janela à mão, monte os mesmos objetos no StarterGui com essas propriedades, defina o ResetOnSpawn do ScreenGui como false ali também e deixe um card como modelo que o LocalScript clona para cada item do catálogo. Aí o script só preenche os cards e conecta os botões. A lógica de compra do próximo passo não muda.
Se o seu jogo abre em um menu principal, aquele guia dá a linha que você adiciona ao ShopClient para o botão Shop aparecer só depois que o jogador aperta Play. Para abrir a loja conversando com um vendedor, o guia de diálogo de NPC mostra como adicionar uma ação OpenShop que manda o ShopClient abrir a janela, enquanto as compras continuam passando pelas checagens de servidor da própria loja.
Passo 4: Confira e conclua as compras no servidor
Este Script é o único lugar em que uma compra pode acontecer. Ele recebe o id do item, confere, procura o preço, confere as Coins do jogador e então tira as moedas e entrega a Tool. Ele responde ao botão Buy com true ou false e uma mensagem para mostrar.
Passe o mouse sobre o ServerScriptService, insira um Script chamado ShopService e cole isto:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- O que o módulo ShopCatalog devolve, para a checagem de tipos strict conferir os campos que usamos
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: o jogador pode usar a tool na hora
local backpack = player:FindFirstChildOfClass("Backpack")
if backpack then
template:Clone().Parent = backpack
end
-- StarterGear: a Roblox copia para a Backpack de novo toda vez que o personagem nasce
local starterGear = player:FindFirstChildOfClass("StarterGear")
if starterGear then
template:Clone().Parent = starterGear
end
end
local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
-- 1. A única coisa que o cliente envia é um id de item, então precisa ser uma string
if type(itemId) ~= "string" then
return false, "That item does not exist."
end
-- 2. Ignora cliques duplos e enxurradas de pedidos feitas por 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. Procura o item na cópia do catálogo do próprio servidor
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. O preço vem do catálogo, nunca do cliente
if coins.Value < item.price then
return false, `You need {item.price - coins.Value} more coins.`
end
-- 5. Tira as moedas e depois entrega o item. Nada aqui faz yield, então dois pedidos
-- do mesmo jogador não conseguem passar pelas checagens acima antes de isto rodar.
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)
A posse fica guardada como um atributo do Player, como Owns_sword. Atributos que o servidor define replicam para o dispositivo do jogador, então o LocalScript consegue mudar aquele card para "Owned". Uma mudança que o jogador faz na própria cópia nunca chega ao servidor.
A Tool vai para dois lugares. A cópia na Backpack aparece na hotbar na hora. A cópia no StarterGear é o que a Roblox coloca na Backpack nova toda vez que o personagem nasce. Sem ela, um item comprado some na primeira vez que o jogador morre.
Por que o cliente nunca envia o preço
Tudo o que está no dispositivo de um jogador pode ser mudado por esse jogador. Exploiters rodam o próprio código na cópia deles do jogo: conseguem ler os seus LocalScripts, editar a GUI e chamar BuyItem:InvokeServer() com quaisquer argumentos, quantas vezes quiserem. O guia de segurança da Roblox diz para conferir o tipo e o valor de tudo o que um remote recebe, e usa uma loja como exemplo.
| Um exploiter envia | Se o servidor confiasse | O que o ShopService faz |
|---|---|---|
| Um preço de 0 | Todo item sai de graça | Ignora. O preço vem do catálogo. |
| Um preço de -1000 | Coins.Value -= -1000 dá 1.000 moedas para ele | Ignora. |
NaN como preço | Toda comparação com NaN é falsa, então uma checagem de "moedas insuficientes" nunca dispara | Ignora. |
| Um id que não está no catálogo, ou uma tabela em vez de uma string | Erros de script, ou itens que você nunca quis vender | Responde "That item does not exist." |
| Centenas de pedidos por segundo | Carga no servidor, e qualquer brecha nas suas checagens é atingida centenas de vezes | Trata no máximo um pedido por jogador a cada meio segundo. |
| Coins editadas na própria tela | Compras com moedas que ele não tem | Nunca vê isso. O servidor lê só o próprio valor de Coins. |
A regra vale para todo remote que você escrever: envie o que o jogador escolheu, como um id de item ou um número de slot, nunca o quanto custa ou o que ele deve receber. O guia de RemoteEvents vai mais fundo na validação de argumentos de remotes.
Passo 5: Teste a loja
- Aperte Play. Um botão Shop aparece à esquerda. Abra e compre a Flashlight: as suas Coins caem 25, a tool aparece na hotbar e o botão dela muda para Owned.
- Tente o Speed Coil, que custa 300. A linha de status diz quantas moedas faltam, e nada é tirado.
- Resete o seu personagem pelo menu do jogo. A Flashlight volta na Backpack nova, graças à cópia no StarterGear.
- Para se dar mais moedas durante o teste, clique no botão Client/Server para mudar para Server, ache
Players, o seu nome,leaderstats,Coinsno Explorer e mude o Value na janela Properties. Fazer a mesma coisa no modo Client muda só a sua tela, que é exatamente o tipo de mudança que o servidor ignora.
Se um botão responder "The shop did not answer", abra a janela Output pelo menu Window do Studio e procure um erro vermelho do ShopService. Se um botão ficar parado em "Buying...", o ShopService não está rodando ou está travado esperando um objeto: veja Erros comuns.
Vendendo um game pass por Robux
Coins são a sua própria moeda, então a loja acima decide cada compra sozinha. O que o jogador compra com Robux funciona de outro jeito: um game pass é comprado uma vez e fica para sempre (vantagens VIP, uma tool permanente), e um developer product pode ser comprado de novo e de novo (um pacote de moedas, um skip). Os dois passam pelo MarketplaceService da Roblox, e quem cobra o pagamento é a Roblox, não o seu script.
Duas regras deste guia continuam valendo: mostre o pedido de compra a partir de um botão no cliente e entregue a vantagem só no servidor, depois que a Roblox confirmar a compra ou quando o jogador já tiver o passe. O guia de script de game pass (em inglês) monta isso do começo ao fim, com checagem de posse ao entrar, o pedido de compra, vantagens como uma porta VIP e quando usar um developer product no lugar. Para escolher um preço, a calculadora de taxa de Robux (em inglês), que é grátis, mostra quanto um passe ou developer product paga para você depois da parte da Roblox.
Salve o que os jogadores compraram
Tudo até aqui dura uma sessão: as moedas e os itens comprados resetam quando o jogador sai, até você salvar tudo com um data store. Em vez de repetir o código de salvamento aqui, siga o tutorial de DataStore (ou o Passo 3 do guia de leaderboard para uma versão mais curta) e lembre destas regras da loja:
- Salve os ids dos itens, como
{ "sword", "flashlight" }, na mesma tabela do valor de Coins, para um único salvamento registrar as moedas gastas e o item comprado. Tools e outras instâncias não podem ser guardadas em um data store. - Quando os dados carregarem, passe pelos ids salvos, pule os que o catálogo não tem mais, defina cada atributo
Owns_e entregue a Tool do mesmo jeito que ogiveToolfaz. A janela da loja se atualiza sozinha, porque ela escuta esses atributos. - A posse de passes não precisa ser salva: o
UserOwnsGamePassAsyncpergunta para a Roblox toda vez que o jogador entra. - Nunca salve um jogador cujos dados falharam ao carregar, ou um carregamento que falhou pode trocar as compras dele por uma lista vazia.
Erros comuns e como resolver
Quando a loja der problema, confira isto primeiro. Abra a janela Output (menu Window, depois Output) antes de tudo: um erro de script mostra o nome do script e a linha.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'
Um script está esperando um objeto que não existe com aquele nome exato. Confira a grafia e as maiúsculas de ShopRemotes, BuyItem, ShopCatalog e ShopItems, e se ShopItems está no ServerStorage, não no ReplicatedStorage. O guia de erros de script explica esse aviso em detalhe.
Um botão Buy fica em "Buying..." e nunca responde
Nada no servidor definiu BuyItem.OnServerInvoke, então a Roblox segura o pedido até alguém definir. Confira se o ShopService é um Script, não um LocalScript, dentro do ServerScriptService, e procure no Output um aviso Infinite yield possible do ShopService: ele quer dizer que o script está travado esperando ShopCatalog, ShopRemotes ou ShopItems.
Um botão Buy diz "The shop did not answer"
A chamada ao servidor falhou em vez de devolver uma resposta. A causa mais comum é um erro dentro do ShopService enquanto ele tratava o pedido, então procure um erro vermelho do ShopService no Output: ele mostra a linha.
Um botão diz "This item is not available right now"
O servidor não achou uma Tool com o toolName daquele item dentro de ServerStorage, ShopItems. O Output mostra um aviso com o nome exato que ele procurou.
Comprei uma tool, mas o meu personagem não consegue segurar, ou fica travado
Uma Tool precisa ter exatamente uma part chamada Handle como filha direta, e nenhuma das parts dela pode estar ancorada. Para uma tool sem nada para segurar, desmarque RequiresHandle.
As moedas caíram na minha tela, mas não para mais ninguém
A compra rodou em um LocalScript, então só o seu dispositivo mudou. Leve a mudança das moedas e a entrega da Tool para um Script de servidor, como no Passo 4.
Os itens comprados somem quando eu volto ao jogo
Nada está sendo salvo ainda. Veja Salve o que os jogadores compraram.
Crie com o RoCode
Se você prefere não montar isso à mão, o RoCode pode construir tudo no jogo que você tem aberto. Ele é um agente de IA independente: você descreve o recurso no chat na web dele, e o plugin dele para o Roblox Studio cria os scripts, o remote e a GUI no seu Explorer, então você não fica copiando código de uma janela de chat.
Adicione uma loja de moedas: um botão Shop que abre uma grade com quatro tools com preço nas Coins das minhas leaderstats. O servidor deve conferir o preço e entregar a tool na Backpack e no StarterGear.
- Pode olhar o seu jogo atrás de leaderstats e código de loja que já existem com Search Scripts e Read Script, para aproveitar o seu valor de Coins em vez de adicionar um segundo
- Pode criar a base da janela com Build UI, cujo layout de loja vem com cards de item de exemplo e um LocalScript para os efeitos de hover e o botão Close; a lógica de compra é escrita em scripts separados
- Cria o RemoteFunction com Create Instance e escreve o ModuleScript do catálogo, o Script de servidor e o LocalScript com Create Script
- Checa a compilação de cada script dentro do Studio com Check Script (ele não faz checagem de tipos nem roda os scripts), e cada lote de mudanças é um ponto de desfazer no Studio
Você ainda cria qualquer passe no Creator Hub por conta própria, porque o RoCode não consegue criar passes nem developer products, e você testa as compras jogando: com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.15 ou mais recente o personagem de teste dele consegue clicar nos botões Shop e Buy, mas ele confere só o que escolheu testar. Uma loja normalmente vem depois do loop principal do jogo e do salvamento; o passo a passo para criar um jogo com o RoCode mostra onde ela entra. Como o RoCode se conecta ao Studio.
Perguntas frequentes
O botão Buy deve usar RemoteEvent ou RemoteFunction?
Os dois funcionam, desde que o servidor faça a checagem. Um RemoteFunction deixa o botão esperar a resposta do servidor e mostrar, por isso este guia usa um, e o guia de segurança da Roblox também usa um RemoteFunction no exemplo de loja. Só chame ele a partir do cliente: um servidor que chama InvokeClient pode esperar para sempre se o cliente nunca responder. O guia de RemoteEvents compara os dois.
Como abrir a loja por um NPC em vez de um botão?
Coloque um ProximityPrompt dentro de uma part do NPC, como o HumanoidRootPart, escute o evento Triggered dele em um Script de servidor e dispare um RemoteEvent para aquele jogador, para o LocalScript mostrar o painel. Se a compra só deve funcionar perto do NPC, confira também a distância até o NPC dentro do handler do BuyItem, porque um cliente pode chamar o remote de qualquer lugar.
Como vender itens que dá para comprar mais de uma vez?
Pule a checagem de "já tem" para esses itens e entregue algo contável em vez de uma Tool, por exemplo somar 1 a um IntValue que conta poções. Mantenha a busca do preço e a checagem das moedas exatamente como estão.
Por que a minha loja some quando o personagem dá respawn?
O ScreenGui dela está com ResetOnSpawn como true, o padrão, então a Roblox apaga ela no respawn. Defina como false, como o script do Passo 3 faz.
Posso usar um template de GUI de loja grátis?
Sim, qualquer layout serve, desde que os botões Buy dele enviem só um id de item e a compra em si aconteça em um Script de servidor como o ShopService. Antes de usar um template, confira se os scripts dele tiram moedas ou entregam itens em um LocalScript.
Fontes e leitura extra
- Roblox Creator Docs: Securing the client-server boundary (em inglês). validar argumentos de remotes, NaN, limite de frequência e o exemplo de loja no jogo
- Roblox Creator Docs: Remote events and callbacks (em inglês). RemoteFunction, InvokeServer, OnServerInvoke e os riscos do InvokeClient
- Roblox Creator Docs: Passes (em inglês). criar e vender passes, UserOwnsGamePassAsync e PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (em inglês). a Shop do jogo que a Roblox cria automaticamente
- Roblox Creator Docs: Developer Products (em inglês). compras repetíveis com Robux e ProcessReceipt
- Roblox Creator Docs: StarterGear (em inglês). por que uma Tool no StarterGear volta depois de um respawn
- Roblox Creator Docs: In-game tools (em inglês). handles, ancoragem e RequiresHandle
Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 14 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.