Tutorial · Sistemas de juego

Cómo hacer una tienda en Roblox Studio

Una tienda en un juego de Roblox son dos trabajos: una GUI que muestra los objetos y un script del servidor que decide si una compra se hace o no. Esta guía construye las dos cosas para una tienda de monedas que vende tools, y muestra dónde encajan las compras con Robux.

Actualizado el 14 de noviembre de 202615 min de lecturaEscrito por

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
  1. Cómo encaja
  2. 1. Preparación
  3. 2. Catálogo de objetos
  4. 3. GUI de la tienda
  5. 4. Compras en el servidor
  6. Por qué el cliente no envía el precio
  7. 5. Pruébala
  8. Game pass
  9. Guardar compras
  10. Errores comunes
  11. Con RoCode
  12. Preguntas frecuentes
  13. Fuentes y lecturas

Cómo encaja una tienda que funciona

IlustraciónEl jugador abre la tienda y compra la Flashlight por 25 monedas: las Coins bajan de 200 a 175, su botón cambia a Owned y la tool aparece en la barra de objetos.

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.

Las cinco piezas de la tienda
PiezaDónde vaQué hace
ModuleScript ShopCatalogReplicatedStorageLos ids, nombres y precios de los objetos, y la Tool que da cada uno. Lo leen los dos lados.
RemoteFunction BuyItemReplicatedStorage, en una carpeta llamada ShopRemotesLleva la petición de compra al servidor y trae la respuesta.
LocalScript ShopClientStarterPlayerScriptsConstruye la ventana de la tienda y envía el id del objeto cuando se pulsa un botón Buy.
Script ShopServiceServerScriptServiceRevisa la petición, quita las Coins y da la Tool.
Las Tools que vendesServerStorage, en una carpeta llamada ShopItemsLos originales que copia el servidor. Nada de ServerStorage se envía a los jugadores.
El Explorer cuando la tienda está terminada
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.

Script en ServerScriptService llamado Leaderstats
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.

  1. En el Explorer, pasa el mouse sobre ReplicatedStorage, haz clic en el botón + e inserta un Folder llamado ShopRemotes. Dentro, inserta un RemoteFunction llamado BuyItem.
  2. Pasa el mouse sobre ServerStorage e inserta un Folder llamado ShopItems.
  3. Pon una Tool por cada objeto dentro de ShopItems, con los nombres ClassicSword, Flashlight, GrappleHook y SpeedCoil. Para una primera prueba, una Tool solo necesita una Part sin anclar llamada Handle dentro. 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.
  4. 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:

ModuleScript en ReplicatedStorage llamado ShopCatalog
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.

  1. En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterPlayerScripts e inserta un LocalScript llamado ShopClient.
  2. Reemplaza su contenido por el código de abajo.
LocalScript en StarterPlayerScripts llamado ShopClient
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.

Los objetos de la GUI y las propiedades que importan
ObjetoSu trabajo en la tiendaPropiedades clave
ScreenGuiContiene todo lo que se dibuja en la pantallaResetOnSpawn en false, para que la tienda sobreviva a una reaparición
FrameLa ventana y cada tarjeta de objetoAnchorPoint 0.5, 0.5 y Position 0.5, 0.5 para centrar la ventana
UISizeConstraintLimita la ventana en pantallas grandesMaxSize 640 por 460
ScrollingFrameHace scroll cuando hay más tarjetas de las que cabenCanvasSize 0 y AutomaticCanvasSize Y, para que la zona de scroll crezca con las tarjetas
UIGridLayoutColoca las tarjetas en filas y las pasa a la fila siguienteCellSize 180 por 200, CellPadding 12, SortOrder LayoutOrder
UICornerRedondea las esquinasCornerRadius de 8 a 14 píxeles
UIPaddingEspacio interiorDe 10 a 12 píxeles en cada lado
TextButtonLos botones Shop, cerrar y BuyEl 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:

Script en ServerScriptService llamado ShopService
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.

Qué pasa si el servidor confía en el cliente
Un exploiter envíaSi el servidor se lo creyeraQué hace ShopService
Un precio de 0Todos los objetos salen gratisLo ignora. El precio sale del catálogo.
Un precio de -1000Coins.Value -= -1000 le da 1,000 monedasLo ignora.
NaN como precioToda comparación con NaN da false, así que la comprobación de "no tienes monedas suficientes" nunca saltaLo ignora.
Un id que no está en el catálogo, o una tabla en vez de un stringErrores en el script, u objetos que nunca quisiste venderResponde "That item does not exist."
Cientos de peticiones por segundoCarga en el servidor, y cualquier hueco en tus comprobaciones se ataca cientos de vecesAtiende como máximo una petición por jugador cada medio segundo.
Monedas editadas en su propia pantallaCompras con monedas que no tieneNunca 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

  1. 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.
  2. 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.
  3. Reinicia tu personaje desde el menú del juego. La Flashlight vuelve en el Backpack nuevo, gracias a la copia de StarterGear.
  4. 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, Coins y 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 hace giveTool. La ventana de la tienda se actualiza sola, porque escucha esos atributos.
  • Los passes no hace falta guardarlos: UserOwnsGamePassAsync le 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.

Tú escribes

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.

RoCode hace
  • 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

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.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.