Como vender itens com Robux no Roblox Studio e salvar no DataStore
Neste tutorial, você vai aprender como criar uma loja no Roblox Studio para vender armas ou itens usando MarketplaceService, RemoteEvent e DataStore. A ideia é que o jogador compre com Robux, receba o item no jogo e tenha essa compra salva.
Projeto prático: o jogador clica no botão da loja, compra com Robux, recebe o item e o sistema salva essa compra no DataStore.
Compra salva no jogo
Quando o jogador voltar para a experiência, o item comprado poderá ser entregue novamente.
O que vamos criar neste sistema de venda com Robux?
Neste projeto, vamos montar uma loja no Roblox Studio em que o jogador pode clicar em um botão, comprar um item com Robux, receber esse item no jogo e ter a compra salva usando DataStore.
Do clique no botão até o item salvo no DataStore
A ideia é mostrar um sistema completo: interface da loja, comunicação com o servidor, compra com Robux, entrega do item e salvamento para quando o jogador voltar ao jogo.
Jogador clica no botão
A interface envia o nome do item escolhido para o servidor.
Servidor abre a compra
O MarketplaceService mostra a janela de compra com Robux.
Item é entregue
Depois da compra, o jogador recebe o item no Backpack.
Compra é salva
O DataStore guarda o item comprado para carregar depois.
Interface da loja
A loja usa botões dentro da ScreenGui. Quando o jogador clica, o LocalScript envia
o nome do item usando RemoteEvent.
RemoteEvent
O RemoteEvent faz a comunicação entre a interface do jogador e o script do servidor, permitindo iniciar a compra com segurança.
MarketplaceService
É o serviço usado para abrir a janela de compra com Robux e processar a compra feita pelo jogador dentro da experiência.
ServerStorage e Backpack
Os itens ficam guardados no ServerStorage. Depois da compra, o item é clonado e enviado para o Backpack do jogador.
DataStore
O DataStore salva os itens comprados para que o jogador não perca a compra quando sair e entrar novamente no jogo.
Lógica de programação
Esse projeto trabalha eventos, funções, tabelas, clonagem de itens, compra com Robux e salvamento de dados.
Importante: nos próximos blocos, vamos colocar os scripts exatamente como usados no vídeo: primeiro o script da interface e depois o script do servidor.
O que preparar no Roblox Studio antes de vender com Robux?
Antes de colar os scripts da aula, é importante montar a estrutura correta no Roblox Studio. O código usa RemoteEvent, itens no ServerStorage, botões na interface e um Developer Product para abrir a compra com Robux.
RemoteEvent no ReplicatedStorage
Crie um RemoteEvent dentro de ReplicatedStorage.
No script da aula, ele precisa se chamar exatamente RemoteEvent.
ScreenGui com Frame
A interface da loja fica dentro de uma ScreenGui.
Dentro dela, o script procura um Frame com os botões dos itens.
Botões com o nome dos itens
Os botões usados no vídeo são HyperlaserGun e SubspaceGun.
Esses nomes precisam bater com os itens que estão no ServerStorage.
Itens no ServerStorage
Coloque as armas ou itens dentro de ServerStorage.
O script procura o item pelo nome recebido quando o jogador clica no botão.
Atributo id no item
Cada item precisa ter um atributo chamado id.
Esse atributo guarda o ID do produto usado na compra com Robux.
DataStore para salvar
O script usa DataStoreService para salvar os itens comprados.
Assim, a compra pode continuar salva quando o jogador sair e voltar.
Confira se tudo está pronto antes de testar o script
Se algum nome estiver diferente, o script pode não encontrar o botão, o item, o RemoteEvent ou o produto de compra. Por isso, siga os nomes usados na aula.
Criar o RemoteEvent dentro de ReplicatedStorage.
Criar a ScreenGui com Frame e botões da loja.
Colocar os itens no ServerStorage.
Adicionar o atributo id nos itens que serão vendidos.
Criar o Developer Product no painel do Roblox.
Ativar o acesso às APIs para testar DataStore no Studio.
Dica importante: mantenha os nomes iguais aos usados no vídeo. Se o botão se chama HyperlaserGun, o item no ServerStorage também precisa ter esse nome.
Como organizar o projeto da loja com Robux no Explorer
Para o script funcionar como mostrado no vídeo, a estrutura precisa estar organizada no Roblox Studio. O sistema usa a interface da loja, um RemoteEvent, itens guardados no ServerStorage e um script no servidor.
ReplicatedStorage
É onde fica o RemoteEvent. Ele permite que o botão da loja envie uma mensagem
para o servidor quando o jogador clicar.
StarterGui
É onde fica a interface da loja. Dentro da ScreenGui, o script procura o Frame
e os botões dos itens.
Botões da loja
Os botões precisam ter o mesmo nome dos itens que serão vendidos, como
HyperlaserGun e SubspaceGun.
ServerStorage
É onde ficam guardados os itens originais. Depois da compra, o script clona o item e envia para o Backpack do jogador.
Atributo id
Cada item vendido precisa ter um atributo chamado id, com o ID do produto
que será comprado com Robux.
ServerScriptService
É onde fica o script principal da loja. Ele recebe o clique, abre a compra, entrega o item e salva os dados.
Atenção aos nomes: se o botão chama HyperlaserGun, o item no ServerStorage também precisa se chamar HyperlaserGun. O script do vídeo depende desses nomes para encontrar o item certo.
LocalScript para enviar o clique da loja ao servidor
Este é o script da interface usado no vídeo. Ele fica dentro da ScreenGui, identifica os botões da loja e usa o RemoteEvent para avisar o servidor qual item o jogador quer comprar.
Clique no botão
Quando o jogador clica em um botão da loja, o script identifica qual item foi escolhido.
RemoteEvent
O RemoteEvent envia para o servidor o nome do botão clicado, como HyperlaserGun ou SubspaceGun.
Loja visual
Esse script não faz a compra diretamente. Ele apenas comunica o clique para o servidor iniciar o processo.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RemoteEvent = ReplicatedStorage:WaitForChild("RemoteEvent")
local player = game.Players.LocalPlayer
local ScreenGui = script.Parent
local Frame = ScreenGui:WaitForChild("Frame")
local Btn1 =Frame:WaitForChild("HyperlaserGun")
local Btn2 = Frame:WaitForChild("SubspaceGun")
Btn1.MouseButton1Click:Connect(function()
print("Cliquei Btn1")
RemoteEvent:FireServer(Btn1.Name)
end)
Btn2.MouseButton1Click:Connect(function()
print("Cliquei Btn2")
RemoteEvent:FireServer(Btn2.Name)
end)Importante: este código deve ficar em um LocalScript dentro da interface da loja. No próximo bloco entra o script do servidor, responsável por abrir a compra, entregar o item e salvar os dados.
Script para vender com Robux, entregar o item e salvar no DataStore
Este é o script principal usado no vídeo. Ele fica no ServerScriptService, recebe o clique enviado pela interface, abre a compra com Robux, entrega o item comprado e salva os dados do jogador no DataStore.
Compra com Robux
O servidor usa o MarketplaceService para abrir a janela de compra do produto.
Entrega do item
Depois da compra, o item é clonado do ServerStorage e colocado no Backpack do jogador.
Salvamento
O DataStore guarda os itens comprados para carregar novamente quando o jogador voltar.
Carregamento
Quando o jogador entra no jogo, o script tenta carregar os itens salvos anteriormente.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RemoteEvent = ReplicatedStorage:WaitForChild("RemoteEvent")
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")
local MarketPlace = game:GetService("MarketplaceService")
local DataStore = game:GetService("DataStoreService")
local StoreItens = DataStore:GetDataStore("Itens")
local PlayerData={}
local function comprar(player,msg)
local arma= ServerStorage:FindFirstChild(msg)
if not arma then
return
end
MarketPlace:PromptProductPurchase(player,arma:GetAttribute("id"))
MarketPlace.ProcessReceipt= function(receiptInfo)
print("comprado")
print(receiptInfo)
local playerComprou = Players:GetPlayerByUserId(receiptInfo.PlayerId)
if not playerComprou then
return Enum.ProductPurchaseDecision.NotProcessedYet
end
if player.UserId == receiptInfo.PlayerId then
local armaClone = arma:Clone()
armaClone.Parent= player.Backpack
if PlayerData[player.UserId].itens[armaClone.Name] then
print("Já tem")
else
PlayerData[player.UserId].itens[armaClone.Name]=1
end
print(PlayerData[player.UserId])
return Enum.ProductPurchaseDecision.PurchaseGranted
end
end
end
RemoteEvent.OnServerEvent:Connect(function(player, msg)
print(player)
print(msg)
comprar(player,msg)
end)
local function entregaItens(player)
for i, v in pairs(PlayerData[player.UserId].itens) do
local item = ServerStorage:FindFirstChild(i)
if item then
item:Clone().Parent = player.Backpack
end
end
end
Players.PlayerAdded:Connect(function(player)
PlayerData[player.UserId]={
itens={}
}
local sucess, data = pcall(function()
return StoreItens:GetAsync(player.UserId)
end)
if sucess then
print(data)
PlayerData[player.UserId]=data
-- entrega itens player
entregaItens(player)
else
warn("Erro ao carregar dados")
end
end)
local function salvarDados(player)
local data = PlayerData[player.UserId]
--data=nil
--PlayerData[player.UserId].itens={}
if data then
local sucess, erro =pcall(function()
StoreItens:SetAsync(player.UserId, data)
end)
if sucess then
print("Salvo com sucesso")
else
print("erro ao salvar")
end
end
end
Players.PlayerRemoving:Connect(function(player)
salvarDados(player)
end)
game:BindToClose(function()
print("Servidor esta fechando , salvando jogadores")
for _, player in pairs(Players:GetPlayers()) do
salvarDados(player)
end
task.wait(3)
end)Importante: este bloco mantém o script igual ao usado na aula gravada. Cole esse código em um Script dentro de ServerScriptService.
Como funciona a venda com Robux e o salvamento no DataStore?
Agora que os scripts já foram apresentados, vale entender o que acontece por trás do sistema. A loja usa uma comunicação entre a interface do jogador e o servidor para abrir a compra, entregar o item e salvar os dados.
O caminho da compra dentro do Roblox Studio
O processo começa no botão da loja e termina no DataStore. Cada parte do script tem uma função: detectar o clique, enviar a mensagem, abrir a compra, entregar o item e guardar a informação.
Clique na loja
O jogador clica em um botão, como HyperlaserGun ou SubspaceGun.
Mensagem ao servidor
O LocalScript usa o RemoteEvent para enviar o nome do item escolhido.
Compra com Robux
O servidor usa MarketplaceService para abrir a janela de compra.
Item salvo
Depois da compra, o item entra no Backpack e é registrado no DataStore.
RemoteEvent
O RemoteEvent faz a ponte entre a interface e o servidor. Ele permite que o botão da loja avise qual item o jogador quer comprar.
MarketplaceService
O MarketplaceService é usado para iniciar a compra com Robux. No vídeo, ele abre a janela de compra do produto configurado.
ProcessReceipt
O ProcessReceipt é a parte que identifica quando a compra foi processada e permite entregar o item ao jogador.
Backpack
O Backpack é onde o jogador recebe o item durante o jogo. Quando a arma é clonada, ela aparece para o jogador usar.
PlayerData
A tabela PlayerData guarda temporariamente os itens comprados pelo jogador enquanto ele está no servidor.
DataStore
O DataStore salva os dados para que o jogador não perca os itens comprados quando sair e voltar para o jogo.
GetAsync
O GetAsync tenta carregar os dados salvos do jogador quando ele entra no jogo.
SetAsync
O SetAsync salva os dados atuais do jogador quando ele sai ou quando o servidor está fechando.
BindToClose
O BindToClose ajuda a salvar os dados dos jogadores quando o servidor está encerrando.
Resumo: este sistema junta interface, RemoteEvent, compra com Robux, entrega de item e DataStore. É um projeto mais avançado e ótimo para quem já quer criar uma loja funcional dentro do Roblox Studio.
Erros comuns ao vender com Robux e salvar no DataStore
Ao criar uma loja com Robux no Roblox Studio, alguns erros são bem comuns. Na maioria das vezes, o problema está em nomes diferentes no Explorer, produto não configurado, atributo ausente ou DataStore sem permissão para funcionar no Studio.
RemoteEvent com nome diferente
O script procura um RemoteEvent dentro de ReplicatedStorage.
O nome precisa estar igual ao usado no vídeo.
Botão com nome diferente
Os botões da loja precisam ter os nomes esperados pelo script, como
HyperlaserGun e SubspaceGun.
Item fora do ServerStorage
Os itens vendidos precisam estar no ServerStorage.
O servidor procura o item pelo nome recebido da interface.
Atributo id ausente
Cada item vendido precisa ter o atributo id, pois ele guarda o ID do produto
usado na compra com Robux.
Produto não criado
A compra só abre corretamente quando o produto foi criado no Roblox e o ID dele foi colocado no atributo do item.
DataStore sem permissão
Para testar salvamento no Roblox Studio, o jogo precisa estar publicado e com acesso às APIs ativado nas configurações da experiência.
Script no lugar errado
O script da interface deve ficar em LocalScript. O script da compra e do DataStore
deve ficar no servidor.
Output ignorado
O Output mostra mensagens importantes, como clique no botão, compra processada, dados carregados e dados salvos.
Entrar e sair muito rápido
No teste de DataStore, é importante dar tempo para o jogo processar a compra, entregar o item e salvar os dados.
Checklist rápido antes de testar a loja com Robux
Antes de achar que o código está errado, confira esta lista. Um único nome diferente pode impedir o script de encontrar o botão, o item, o RemoteEvent ou o produto da compra.
RemoteEvent está dentro de ReplicatedStorage?
Botões estão dentro do Frame da ScreenGui?
Itens estão dentro do ServerStorage?
O atributo id foi colocado no item?
O Developer Product foi criado no Roblox?
O jogo foi publicado para testar DataStore?
O acesso às APIs está ativado nas configurações?
O Output mostra mensagens de clique e salvamento?
Os nomes dos botões e dos itens estão iguais?
Dica: quando algo não funcionar, teste por partes. Primeiro veja se o botão imprime no Output, depois confira se o RemoteEvent chega ao servidor, em seguida teste a compra e por último verifique o salvamento no DataStore.
Seu filho quer ir além de jogar e começar a criar jogos?
Na Programação for Kids, crianças e adolescentes aprendem programação criando projetos no Roblox Studio: lojas, moedas, sistemas de compra, scripts, mapas, desafios e jogos completos. Tudo de forma prática, criativa e com linguagem adequada para a idade.
O aluno aprende programação criando projetos reais
Em vez de apenas assistir ou copiar códigos soltos, o aluno entende a lógica por trás dos sistemas e aprende a criar seus próprios jogos dentro do Roblox Studio.
Programação em Lua
Projetos no Roblox
Raciocínio lógico
Criação de jogos
Ideal para crianças e adolescentes que gostam de Roblox e querem aprender tecnologia de um jeito divertido.
Dúvidas sobre vender itens com Robux e salvar no DataStore
Veja as principais dúvidas sobre como criar uma loja com Robux no Roblox Studio, usar MarketplaceService, enviar informações com RemoteEvent e salvar os itens comprados no DataStore.
Um sistema completo para vender, entregar e salvar itens
Esse tipo de projeto é muito útil para jogos no Roblox que possuem loja, armas, poderes, ferramentas, skins ou itens especiais comprados com Robux.
O jogador escolhe um item dentro da loja do jogo.
A compra é aberta usando MarketplaceService.
O item é entregue no Backpack do jogador.
O DataStore salva a compra para o jogador não perder o item.
Como vender itens com Robux no Roblox Studio?
Para vender itens com Robux no Roblox Studio, você precisa criar um produto no Roblox,
usar MarketplaceService para abrir a compra e entregar o item quando a compra for processada.
Para que serve o MarketplaceService?
O MarketplaceService é o serviço usado para trabalhar com compras dentro do Roblox,
como abrir a janela de compra com Robux e processar a compra do jogador.
O que é Developer Product no Roblox?
Developer Product é um produto criado para ser vendido dentro de uma experiência Roblox. No exemplo da aula, ele é usado para vender itens ou armas usando Robux.
Por que usar RemoteEvent na loja?
O RemoteEvent permite que o botão da interface envie uma mensagem para o servidor.
Assim, o servidor sabe qual item o jogador quer comprar.
Como salvar o item comprado no DataStore?
Depois que o jogador compra o item, o script registra esse item em uma tabela de dados
e usa o DataStore para salvar as informações do jogador.
Por que o item precisa ficar no ServerStorage?
O ServerStorage é usado para guardar itens no servidor.
Depois da compra, o script encontra o item, clona e coloca no Backpack do jogador.
Preciso publicar o jogo para testar DataStore?
Sim. Para testar DataStore corretamente no Roblox Studio, a experiência precisa estar publicada e o acesso às APIs precisa estar ativado nas configurações do jogo.
Resumo: vender com Robux no Roblox Studio envolve interface, RemoteEvent, MarketplaceService, entrega do item e DataStore. Quando essas partes trabalham juntas, o jogador compra o item e pode continuar com ele depois.
Outros tutoriais de Roblox Studio que você também pode aprender
Depois de aprender como vender itens com Robux e salvar compras no DataStore, veja outros sistemas que ajudam a deixar seu jogo mais completo.
Como criar uma loja no Roblox Studio
Aprenda a montar uma loja dentro do jogo para vender itens, organizar botões e criar uma interface mais profissional.
Ver tutorialComo salvar progresso com DataStore
Veja como salvar moedas, pontos e progresso do jogador usando DataStore no Roblox Studio.
Ver tutorialComo fazer teleport no Roblox Studio
Aprenda a criar sistemas de teleporte para mapas, fases, áreas secretas e jogos com diferentes mundos.
Ver tutorialComo publicar um jogo no Roblox
Entenda como publicar sua experiência, configurar o jogo e deixar o projeto disponível para outros jogadores.
Ver tutorialPlugins úteis para Roblox Studio
Conheça ferramentas que ajudam na construção de mapas, organização do projeto e criação de jogos no Roblox.
Ver tutorialAula experimental de Roblox Studio
Seu filho gosta de Roblox? Ele pode aprender programação criando os próprios jogos de forma prática e divertida.
Agendar aula













