La respuesta corta
Guarda tus objetos y precios en un ModuleScript en ReplicatedStorage, arma la ventana con un ScreenGui, un ScrollingFrame y un UIGridLayout, y haz que cada botón Buy llame a un RemoteFunction enviando solo el id del objeto. Después, un Script en ServerScriptService busca el precio por su cuenta, revisa y quita las Coins del jugador, y le da el objeto.
- Nunca dejes que el cliente envíe el precio. Cualquiera puede llamar a tus remotes con cualquier valor, así que el servidor lee el precio de su propia copia del catálogo.
- Para dar una Tool comprada, clónala desde ServerStorage al Backpack del jugador (para usarla ya) y a StarterGear (para que vuelva después de reaparecer).
- Lo que se vende por Robux son passes y developer products, y se manejan con MarketplaceService. Roblox también crea una Shop automática para eso, que es algo aparte de una tienda de monedas.
En esta página
Cómo encaja una tienda que funciona
Una tienda que funciona en un juego en vivo está repartida entre el dispositivo del jugador y el servidor. El dispositivo dibuja la ventana y dice "quiero comprar la espada". El servidor, el único lado en el que puedes confiar, decide si eso pasa. Los scripts de tienda que "no funcionan", o que los jugadores explotan, muchas veces toman esa decisión en el lado equivocado.
| Pieza | Dónde va | Qué hace |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | Los ids, nombres y precios de los objetos, y la Tool que da cada uno. Lo leen los dos lados. |
RemoteFunction BuyItem | ReplicatedStorage, en una carpeta llamada ShopRemotes | Lleva la petición de compra al servidor y trae la respuesta. |
LocalScript ShopClient | StarterPlayerScripts | Construye la ventana de la tienda y envía el id del objeto cuando se pulsa un botón Buy. |
Script ShopService | ServerScriptService | Revisa la petición, quita las Coins y da la Tool. |
| Las Tools que vendes | ServerStorage, en una carpeta llamada ShopItems | Los originales que copia el servidor. Nada de ServerStorage se envía a los jugadores. |
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
Paso 1: Prepara las monedas y los objetos a la venta
La tienda gasta un valor Coins en los leaderstats del jugador. Si seguiste la guía del leaderboard ya tienes uno, así que sáltate este script. Si no, inserta un Script en ServerScriptService llamado Leaderstats. Empieza a todos con 200 monedas para que puedas probar compras desde el principio.
local Players = game:GetService("Players")
local STARTING_COINS = 200 -- suficiente para probar la tienda; ponlo en 0 cuando los jugadores puedan ganar monedas
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
Ten un solo script de leaderstats. Dos scripts que crean cada uno una carpeta leaderstats le dan a cada jugador dos carpetas, y la tienda puede leer la equivocada.
Ahora crea los objetos que buscan los scripts. Los nombres distinguen mayúsculas y minúsculas, así que escríbelos tal cual.
- En el Explorer, pasa el mouse sobre ReplicatedStorage, haz clic en el botón + e inserta un Folder llamado
ShopRemotes. Dentro, inserta un RemoteFunction llamadoBuyItem. - Pasa el mouse sobre ServerStorage e inserta un Folder llamado
ShopItems. - Pon una Tool por cada objeto dentro de ShopItems, con los nombres
ClassicSword,Flashlight,GrappleHookySpeedCoil. Para una primera prueba, una Tool solo necesita una Part sin anclar llamadaHandledentro. Cualquier Tool que ya tengas también sirve: ponle el nombre que corresponde. Para un arma que haga daño de verdad, constrúyela con la guía de la espada o la guía del arma de fuego (en inglés); cada una explica cómo hacerla coincidir con el catálogo. - Selecciona cada Tool y desmarca CanBeDropped en la ventana Properties. Si está marcado, al pulsar Retroceso la tool cae al Workspace, y cualquier jugador puede recoger lo que pagó el comprador.
Puedes empezar con una sola Tool. Si falta la Tool de un objeto, el servidor se niega a venderlo y muestra una advertencia con su nombre, así que al jugador no se le quita nada.
Paso 2: Pon los objetos y los precios en un catálogo
El catálogo es la única lista de todo lo que vende la tienda. El LocalScript lo lee para dibujar las tarjetas y el servidor lo lee para encontrar los precios, así que cambiar un precio es un solo cambio en un solo lugar.
Pasa el mouse sobre ReplicatedStorage, inserta un ModuleScript, cámbiale el nombre a ShopCatalog y reemplaza su contenido por esto:
export type ShopItem = {
id: string, -- se guarda luego en data stores: no lo cambies nunca cuando alguien ya tenga el objeto
name: string, -- se muestra en la tarjeta; puedes cambiarlo
price: number, -- en Coins
description: string,
toolName: string, -- la Tool de ServerStorage.ShopItems que recibe el jugador
}
-- Las tarjetas aparecen en este orden
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
-- Devuelve el objeto con este id, o nil si no existe
function ShopCatalog.get(id: string): ShopItem?
return byId[id]
end
-- El atributo del Player que el servidor pone en true cuando el jugador tiene un objeto
function ShopCatalog.ownedAttribute(id: string): string
return "Owns_" .. id
end
return ShopCatalog
Cada objeto tiene un id además de un name para mostrar. El id es lo que guarda el servidor cuando un jugador tiene algo, así que puedes renombrar "Classic Sword" más adelante sin romper las compras guardadas. Las descripciones son solo texto en la tarjeta; lo que hace una Tool depende de sus propios scripts.
Los jugadores pueden leer un ModuleScript en ReplicatedStorage, así que estos precios son públicos. No pasa nada: igual están escritos en las tarjetas. Lo importante es que el cliente y el servidor ejecutan cada uno su propia copia del módulo, así que un jugador que cambia los precios en su dispositivo no cambia nada en el servidor.
Paso 3: Construye la GUI de la tienda
Este LocalScript construye toda la ventana con código: un botón Shop, un panel con una cuadrícula de tarjetas con scroll, un botón Buy por cada objeto del catálogo, un contador de Coins y una línea de estado para las respuestas del servidor. Como todo es código, puedes pegarlo y pulsar Play. La tabla de después lista cada objeto por si prefieres armar la ventana a mano.
- En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterPlayerScripts e inserta un LocalScript llamado
ShopClient. - Reemplaza su contenido por el código de abajo.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Lo que devuelve el módulo ShopCatalog, para que el modo strict compruebe los 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: contiene todo lo que la tienda dibuja en la pantalla del jugador
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- conserva la tienda cuando el personaje reaparece
-- Un botón en el borde izquierdo que abre y cierra la tienda
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 ventana de la tienda: centrada y oculta hasta que el jugador la abre
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) -- evita que la ventana se haga enorme en pantallas 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
-- Aquí se muestran las respuestas del servidor, como "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: la zona que se desplaza cuando hay más tarjetas de las que caben
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() -- empieza en cero; AutomaticCanvasSize lo agranda para que quepan las tarjetas
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel
-- UIGridLayout: coloca las tarjetas en filas y pasa a la fila siguiente cuando no caben
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..."
-- Envía solo el id del objeto. El servidor busca el precio por su cuenta.
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)
-- El servidor pone este atributo cuando la compra se completa (o cuando cargan los objetos guardados)
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")
-- Muestra las monedas del jugador. El valor real es del servidor; esto solo lo muestra.
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()
Los botones usan Activated en vez de MouseButton1Click: se dispara con un clic del mouse, un toque en el celular y el botón A o X de un mando.
Las definiciones type del principio describen lo que devuelve ShopCatalog, para que el modo strict detecte un campo mal escrito como item.prise. No cambian nada cuando el juego se ejecuta.
| Objeto | Su trabajo en la tienda | Propiedades clave |
|---|---|---|
ScreenGui | Contiene todo lo que se dibuja en la pantalla | ResetOnSpawn en false, para que la tienda sobreviva a una reaparición |
Frame | La ventana y cada tarjeta de objeto | AnchorPoint 0.5, 0.5 y Position 0.5, 0.5 para centrar la ventana |
UISizeConstraint | Limita la ventana en pantallas grandes | MaxSize 640 por 460 |
ScrollingFrame | Hace scroll cuando hay más tarjetas de las que caben | CanvasSize 0 y AutomaticCanvasSize Y, para que la zona de scroll crezca con las tarjetas |
UIGridLayout | Coloca las tarjetas en filas y las pasa a la fila siguiente | CellSize 180 por 200, CellPadding 12, SortOrder LayoutOrder |
UICorner | Redondea las esquinas | CornerRadius de 8 a 14 píxeles |
UIPadding | Espacio interior | De 10 a 12 píxeles en cada lado |
TextButton | Los botones Shop, cerrar y Buy | El evento Activated |
Para diseñar la ventana a mano, construye los mismos objetos dentro de StarterGui con esas propiedades, pon también ahí ResetOnSpawn del ScreenGui en false y deja una tarjeta como plantilla que el LocalScript clona por cada objeto del catálogo. Así el script solo rellena las tarjetas y conecta los botones. La lógica de compra del paso siguiente no cambia.
Si tu juego empieza en un menú principal, esa guía da la línea que hay que añadir a ShopClient para que el botón Shop aparezca solo después de que el jugador pulse Play. Para abrir la tienda hablando con un vendedor, la guía de diálogo de NPC muestra cómo añadir una acción OpenShop que le dice a ShopClient que abra su ventana, mientras las compras siguen pasando por las comprobaciones del servidor de la tienda.
Paso 4: Revisa y completa las compras en el servidor
Este Script es el único lugar donde puede pasar una compra. Recibe el id del objeto, lo revisa, busca el precio, revisa las Coins del jugador, y luego quita las monedas y da la Tool. Le responde al botón Buy con true o false y un mensaje para mostrar.
Pasa el mouse sobre ServerScriptService, inserta un Script llamado ShopService y pega esto:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")
-- Lo que devuelve el módulo ShopCatalog, para que el modo strict compruebe los 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: el jugador puede usar la tool enseguida
local backpack = player:FindFirstChildOfClass("Backpack")
if backpack then
template:Clone().Parent = backpack
end
-- StarterGear: Roblox la copia otra vez al Backpack cada vez que aparece el personaje
local starterGear = player:FindFirstChildOfClass("StarterGear")
if starterGear then
template:Clone().Parent = starterGear
end
end
local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
-- 1. Lo único que envía el cliente es un id de objeto, así que debe ser un string
if type(itemId) ~= "string" then
return false, "That item does not exist."
end
-- 2. Ignora los dobles clics y las avalanchas de peticiones hechas con scripts
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. Busca el objeto en la copia del catálogo que tiene el propio 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. El precio sale del catálogo, nunca del cliente
if coins.Value < item.price then
return false, `You need {item.price - coins.Value} more coins.`
end
-- 5. Quita las monedas y luego da el objeto. Nada aquí hace yield, así que dos peticiones
-- del mismo jugador no pueden pasar las dos las comprobaciones de arriba antes de que esto se ejecute.
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)
Que el jugador tiene un objeto se guarda como un atributo del Player, por ejemplo Owns_sword. Los atributos que pone el servidor se replican al dispositivo del jugador, así que el LocalScript puede cambiar esa tarjeta a "Owned". Un cambio que un jugador hace en su propia copia nunca llega al servidor.
La Tool va a dos lugares. La copia del Backpack aparece en la barra de objetos al instante. La copia de StarterGear es la que Roblox pone en el Backpack nuevo cada vez que aparece el personaje. Sin ella, un objeto comprado desaparece la primera vez que el jugador muere.
Por qué el cliente nunca envía el precio
Todo lo que está en el dispositivo de un jugador lo puede cambiar ese jugador. Los exploiters ejecutan su propio código en su copia del juego: pueden leer tus LocalScripts, editar la GUI y llamar a BuyItem:InvokeServer() con los argumentos que quieran, todas las veces que quieran. La guía de seguridad de Roblox dice que hay que revisar el tipo y el valor de todo lo que recibe un remote, y usa una tienda como ejemplo.
| Un exploiter envía | Si el servidor se lo creyera | Qué hace ShopService |
|---|---|---|
| Un precio de 0 | Todos los objetos salen gratis | Lo ignora. El precio sale del catálogo. |
| Un precio de -1000 | Coins.Value -= -1000 le da 1,000 monedas | Lo ignora. |
NaN como precio | Toda comparación con NaN da false, así que la comprobación de "no tienes monedas suficientes" nunca salta | Lo ignora. |
| Un id que no está en el catálogo, o una tabla en vez de un string | Errores en el script, u objetos que nunca quisiste vender | Responde "That item does not exist." |
| Cientos de peticiones por segundo | Carga en el servidor, y cualquier hueco en tus comprobaciones se ataca cientos de veces | Atiende como máximo una petición por jugador cada medio segundo. |
| Monedas editadas en su propia pantalla | Compras con monedas que no tiene | Nunca lo ve. El servidor solo lee su propio valor de Coins. |
La regla vale para cada remote que escribas: envía lo que eligió el jugador, como un id de objeto o un número de casilla, nunca lo que cuesta ni lo que debería recibir. La guía de RemoteEvents profundiza en cómo validar los argumentos de un remote.
Paso 5: Prueba la tienda
- Pulsa Play. Aparece un botón Shop a la izquierda. Ábrelo y compra la Flashlight: tus Coins bajan 25, la tool aparece en tu barra de objetos y su botón cambia a Owned.
- Prueba con la Speed Coil, que cuesta 300. La línea de estado dice cuántas monedas te faltan, y no se te quita nada.
- Reinicia tu personaje desde el menú del juego. La Flashlight vuelve en el Backpack nuevo, gracias a la copia de StarterGear.
- Para darte más monedas mientras pruebas, haz clic en el interruptor Client/Server para pasar a Server, busca en el Explorer
Players, tu nombre,leaderstats,Coinsy cambia su Value en la ventana Properties. Si haces lo mismo en modo Client, solo cambia tu pantalla, que es justo el tipo de cambio que el servidor ignora.
Si un botón responde "The shop did not answer", abre la ventana Output desde el menú Window de Studio y busca un error rojo de ShopService. Si en cambio un botón se queda en "Buying...", ShopService no se está ejecutando o está atascado esperando un objeto: consulta Errores comunes.
Vender un game pass por Robux
Las Coins son tu propia moneda, así que la tienda de arriba decide cada compra ella sola. Lo que un jugador compra con Robux funciona distinto: un game pass se compra una vez y se queda (ventajas VIP, una tool permanente), y un developer product se puede comprar una y otra vez (un paquete de monedas, un salto de nivel). Los dos pasan por MarketplaceService de Roblox, y es Roblox, no tu script, quien cobra el pago.
De esta guía se mantienen dos reglas: muestra la compra desde un botón en el cliente, y da la ventaja solo en el servidor cuando Roblox confirma la compra o el jugador ya tiene el pass. La guía del script de game pass de Roblox (en inglés) lo construye de principio a fin, con la comprobación de propiedad al entrar, el aviso de compra, ventajas como una puerta VIP y cuándo usar un developer product en su lugar. Para elegir un precio, la calculadora gratis del impuesto de Robux (en inglés) muestra cuánto te paga un pass o un developer product después de la parte de Roblox.
Guarda lo que compraron los jugadores
Todo lo que hay hasta ahora dura una sesión: las monedas y los objetos comprados se reinician cuando el jugador sale, hasta que los guardes con un data store. En vez de repetir aquí el código de guardado, sigue el tutorial de DataStore (o el Paso 3 de la guía del leaderboard para una versión más corta) y ten en cuenta estas reglas de la tienda:
- Guarda los ids de los objetos, como
{ "sword", "flashlight" }, en la misma tabla que el valor de Coins, para que un solo guardado registre a la vez las monedas gastadas y el objeto comprado. Las Tools y otras instancias no se pueden guardar en un data store. - Cuando carguen los datos, recorre los ids guardados, sáltate los que el catálogo ya no tenga, pon cada atributo
Owns_y da la Tool igual que lo hacegiveTool. La ventana de la tienda se actualiza sola, porque escucha esos atributos. - Los passes no hace falta guardarlos:
UserOwnsGamePassAsyncle pregunta a Roblox cada vez que el jugador entra. - Nunca guardes a un jugador cuyos datos no cargaron, o una carga fallida puede reemplazar sus compras por una lista vacía.
Errores comunes y soluciones
Cuando la tienda falla, revisa esto primero. Abre la ventana Output (menú Window y luego Output) antes que nada: un error de script dice el nombre del script y la línea.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'
Un script está esperando un objeto que no existe con ese nombre exacto. Revisa cómo están escritos, con sus mayúsculas, ShopRemotes, BuyItem, ShopCatalog y ShopItems, y que ShopItems esté en ServerStorage y no en ReplicatedStorage. La guía de errores de scripts explica esta advertencia en detalle.
Un botón Buy se queda en "Buying..." y nunca responde
Nada en el servidor ha puesto BuyItem.OnServerInvoke, así que Roblox retiene la petición hasta que algo lo haga. Asegúrate de que ShopService es un Script, no un LocalScript, dentro de ServerScriptService, y busca en Output una advertencia Infinite yield possible de ShopService: significa que el script está atascado esperando ShopCatalog, ShopRemotes o ShopItems.
Un botón Buy dice "The shop did not answer"
La llamada al servidor falló en vez de devolver una respuesta. Lo normal es que haya un error dentro de ShopService mientras atendía la petición, así que busca en Output un error rojo de ShopService: dice la línea.
Un botón dice "This item is not available right now"
El servidor no encontró una Tool con el toolName de ese objeto dentro de ServerStorage, ShopItems. Output muestra una advertencia con el nombre exacto que buscó.
Compré una tool pero mi personaje no la puede agarrar, o se queda atascado
Una Tool necesita exactamente una parte llamada Handle como hija directa, y ninguna de sus partes puede estar anclada. Para una tool sin nada que agarrar, desmarca RequiresHandle.
Las monedas bajaron en mi pantalla pero no para los demás
La compra se hizo en un LocalScript, así que solo cambió tu dispositivo. Pasa el cambio de monedas y la entrega de la Tool a un Script del servidor, como en el Paso 4.
Los objetos comprados desaparecen cuando vuelvo a entrar
Todavía no se guarda nada. Consulta Guarda lo que compraron los jugadores.
Constrúyelo con RoCode
Si prefieres no conectar todo esto a mano, RoCode puede construirlo en el place que tienes abierto. Es un agente de IA independiente para programar: describes la función en su chat web y su plugin de Roblox Studio crea los scripts, el remote y la GUI en tu Explorer, así que no copias código de una ventana de chat.
Añade una tienda de monedas: un botón Shop que abra una cuadrícula de cuatro tools con precios en las Coins de mis leaderstats. El servidor debe revisar el precio y dar la tool al Backpack y a StarterGear.
- Puede revisar tu place en busca de leaderstats y código de tienda que ya tengas con Search Scripts y Read Script, para reutilizar tu valor de Coins en vez de añadir un segundo
- Puede armar la base de la ventana con Build UI, cuyo diseño de tienda trae tarjetas de objetos de ejemplo y un LocalScript para los efectos al pasar el mouse y el botón de cerrar; la lógica de compra se escribe en scripts aparte
- Crea el RemoteFunction con Create Instance, y escribe el ModuleScript del catálogo, el Script del servidor y el LocalScript con Create Script
- Comprueba que cada script compila dentro de Studio con Check Script (no revisa tipos ni los ejecuta), y cada lote de cambios es un punto de deshacer en Studio
Los passes los sigues creando tú en Creator Hub, porque RoCode no puede crear passes ni developer products, y las compras las pruebas tú: con el plugin 3.9 o posterior RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.15 o posterior su personaje de prueba puede hacer clic en los botones Shop y Buy, pero solo comprueba lo que eligió probar. Una tienda suele venir después del bucle principal del juego y del guardado; el proceso paso a paso para construir un juego con RoCode (en inglés) muestra dónde encaja. Cómo se conecta RoCode a Studio.
Preguntas frecuentes
¿El botón Buy debe usar un RemoteEvent o un RemoteFunction?
Cualquiera de los dos sirve, siempre que el servidor haga las comprobaciones. Un RemoteFunction deja que el botón espere la respuesta del servidor y la muestre, por eso esta guía usa uno, y la guía de seguridad de Roblox también usa un RemoteFunction en su ejemplo de tienda. Invócalo solo desde el cliente: un servidor que llama a InvokeClient puede quedarse esperando para siempre si el cliente nunca responde. La guía de RemoteEvents compara los dos.
¿Cómo abro la tienda desde un NPC en vez de un botón?
Pon un ProximityPrompt dentro de una parte del NPC, como su HumanoidRootPart, escucha su evento Triggered en un Script del servidor y dispara un RemoteEvent a ese jugador para que el LocalScript muestre el panel. Si solo se debe poder comprar cerca del NPC, revisa también la distancia al NPC dentro del manejador de BuyItem, porque un cliente puede llamar al remote desde cualquier lugar.
¿Cómo vendo objetos que se pueden comprar más de una vez?
Quita la comprobación de "ya lo tienes" para esos objetos y da algo que se pueda contar en vez de una Tool, por ejemplo suma 1 a un IntValue que cuenta pociones. Deja la búsqueda del precio y la comprobación de monedas exactamente como están.
¿Por qué mi tienda desaparece cuando mi personaje reaparece?
Su ScreenGui tiene ResetOnSpawn en true, el valor por defecto, así que Roblox la borra al reaparecer. Ponlo en false, como hace el script del Paso 3.
¿Puedo usar una plantilla gratis de tienda GUI?
Sí, sirve cualquier diseño, siempre que sus botones Buy solo envíen un id de objeto y la compra en sí se haga en un Script del servidor como ShopService. Antes de usar una plantilla, revisa si sus scripts quitan monedas o dan objetos en un LocalScript.
Fuentes y lecturas
- Roblox Creator Docs: Securing the client-server boundary (en inglés). validar los argumentos de un remote, NaN, límite de peticiones y el ejemplo de la tienda del juego
- Roblox Creator Docs: Remote events and callbacks (en inglés). RemoteFunction, InvokeServer, OnServerInvoke y los riesgos de InvokeClient
- Roblox Creator Docs: Passes (en inglés). crear y vender passes, UserOwnsGamePassAsync y PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (en inglés). la Shop del juego que Roblox crea automáticamente
- Roblox Creator Docs: Developer Products (en inglés). compras con Robux que se repiten y ProcessReceipt
- Roblox Creator Docs: StarterGear (en inglés). por qué una Tool en StarterGear vuelve después de reaparecer
- Roblox Creator Docs: In-game tools (en inglés). el Handle, el anclaje y RequiresHandle
Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 14 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.