Tutorial · Sistemas de jogo

Como fazer uma loja no Roblox Studio

Uma loja em um jogo do Roblox são dois trabalhos: uma GUI que mostra os itens e um script de servidor que decide se a compra acontece. Este guia monta os dois para uma loja de moedas que vende tools, e mostra onde entram as compras com Robux.

Atualizado em 14 de novembro de 202615 min de leituraEscrito por

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
  1. Como funciona
  2. 1. Preparação
  3. 2. Catálogo de itens
  4. 3. GUI da loja
  5. 4. Compras no servidor
  6. Por que sem preço do cliente
  7. 5. Teste
  8. Game pass
  9. Salvar compras
  10. Erros comuns
  11. Com o RoCode
  12. Perguntas frequentes
  13. Fontes e leitura extra

Como as peças de uma loja funcionam juntas

IlustraçãoO jogador abre a loja e compra a Flashlight por 25 moedas: as Coins caem de 200 para 175, o botão dela muda para Owned e a tool aparece na hotbar.

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.

As cinco peças da loja
PeçaOnde ficaO que faz
ModuleScript ShopCatalogReplicatedStorageIds, nomes e preços dos itens e a Tool que cada um entrega. Os dois lados leem.
RemoteFunction BuyItemReplicatedStorage, em uma pasta chamada ShopRemotesLeva o pedido de compra para o servidor e traz a resposta de volta.
LocalScript ShopClientStarterPlayerScriptsMonta a janela da loja e envia o id do item quando um botão Buy é apertado.
Script ShopServiceServerScriptServiceConfere o pedido, tira as Coins e entrega a Tool.
As Tools que você vendeServerStorage, em uma pasta chamada ShopItemsOs originais que o servidor copia. Nada no ServerStorage é enviado aos jogadores.
O Explorer quando a loja está pronta
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.

Script em ServerScriptService chamado Leaderstats
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.

  1. No Explorer, passe o mouse sobre o ReplicatedStorage, clique no botão + e insira uma Folder chamada ShopRemotes. Dentro dela, insira um RemoteFunction chamado BuyItem.
  2. Passe o mouse sobre o ServerStorage e insira uma Folder chamada ShopItems.
  3. Coloque uma Tool para cada item dentro de ShopItems, com os nomes ClassicSword, Flashlight, GrappleHook e SpeedCoil. Para um primeiro teste, uma Tool só precisa de uma Part não ancorada chamada Handle dentro 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.
  4. 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:

ModuleScript em ReplicatedStorage chamado ShopCatalog
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.

  1. No Explorer, expanda o StarterPlayer, passe o mouse sobre o StarterPlayerScripts e insira um LocalScript chamado ShopClient.
  2. Troque o conteúdo dele pelo código abaixo.
LocalScript em StarterPlayerScripts chamado ShopClient
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.

Os objetos da GUI e as propriedades que importam
ObjetoPapel na lojaPropriedades principais
ScreenGuiGuarda tudo o que é desenhado na telaResetOnSpawn false, para a loja sobreviver a um respawn
FrameA janela e cada card de itemAnchorPoint 0.5, 0.5 e Position 0.5, 0.5 para centralizar a janela
UISizeConstraintLimita a janela em telas grandesMaxSize 640 por 460
ScrollingFrameRola quando há mais cards do que cabemCanvasSize 0 e AutomaticCanvasSize Y, para a área de rolagem crescer com os cards
UIGridLayoutColoca os cards em linhas e quebra para a próximaCellSize 180 por 200, CellPadding 12, SortOrder LayoutOrder
UICornerArredonda os cantosCornerRadius de 8 a 14 pixels
UIPaddingEspaço interno10 a 12 pixels de cada lado
TextButtonBotões Shop, fechar e BuyO 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:

Script em ServerScriptService chamado ShopService
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.

O que acontece se o servidor confia no cliente
Um exploiter enviaSe o servidor confiasseO que o ShopService faz
Um preço de 0Todo item sai de graçaIgnora. O preço vem do catálogo.
Um preço de -1000Coins.Value -= -1000 dá 1.000 moedas para eleIgnora.
NaN como preçoToda comparação com NaN é falsa, então uma checagem de "moedas insuficientes" nunca disparaIgnora.
Um id que não está no catálogo, ou uma tabela em vez de uma stringErros de script, ou itens que você nunca quis venderResponde "That item does not exist."
Centenas de pedidos por segundoCarga no servidor, e qualquer brecha nas suas checagens é atingida centenas de vezesTrata no máximo um pedido por jogador a cada meio segundo.
Coins editadas na própria telaCompras com moedas que ele não temNunca 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

  1. 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.
  2. Tente o Speed Coil, que custa 300. A linha de status diz quantas moedas faltam, e nada é tirado.
  3. Resete o seu personagem pelo menu do jogo. A Flashlight volta na Backpack nova, graças à cópia no StarterGear.
  4. Para se dar mais moedas durante o teste, clique no botão Client/Server para mudar para Server, ache Players, o seu nome, leaderstats, Coins no 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 o giveTool faz. A janela da loja se atualiza sozinha, porque ela escuta esses atributos.
  • A posse de passes não precisa ser salva: o UserOwnsGamePassAsync pergunta 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.

Você digita

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.

O RoCode faz
  • 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

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.

Teste o RoCode no seu próprio jogo.

Créditos grátis todo dia, sem cartão. Instale o plugin, descreva o recurso e confira o que aparece no Studio.