Tutorial · Gamesystemen

Een winkel maken in Roblox Studio

Een winkel in een Roblox-game bestaat uit twee taken: een GUI die de items toont, en een serverscript dat beslist of een aankoop doorgaat. In deze handleiding bouwen we allebei voor een winkel met munten die tools verkoopt, en laten we zien waar aankopen met Robux thuishoren.

Bijgewerkt 20 november 202614 min lezenAuteur:

In het kort

Bewaar items en prijzen in een ModuleScript in ReplicatedStorage, bouw het venster uit een ScreenGui, ScrollingFrame en UIGridLayout, en laat elke Buy-knop een RemoteFunction aanroepen die alleen het item-id doorgeeft. Daarna zoekt een Script in ServerScriptService zelf de prijs op, controleert en verrekent de Coins van de speler en geeft het item.

  • Laat de client nooit de prijs sturen. Iedereen kan je remotes aanroepen met welke waarden dan ook, dus de server haalt de prijs uit zijn eigen kopie van de catalogus.
  • Geef een gekochte Tool door hem uit ServerStorage te klonen naar de Backpack van de speler (om hem meteen te gebruiken) en naar StarterGear (zodat hij na een respawn terugkomt).
  • Wat je voor Robux verkoopt, zijn passes en developer products, en die lopen via MarketplaceService. Daarvoor maakt Roblox ook zelf een Shop, en dat is niet hetzelfde als een winkel met munten.
Op deze pagina
  1. Hoe het werkt
  2. 1. Voorbereiding
  3. 2. Itemcatalogus
  4. 3. Winkel-GUI
  5. 4. Aankopen op de server
  6. Waarom geen prijs van de client
  7. 5. Testen
  8. Gamepass
  9. Aankopen opslaan
  10. Common errors
  11. Met RoCode
  12. Veelgestelde vragen
  13. Bronnen en verder lezen

Hoe een werkende winkel in elkaar zit

IllustratieEen speler opent de winkel en koopt Flashlight voor 25 munten: Coins zakken van 200 naar 175, de knop verandert in Owned en de tool verschijnt in de hotbar.

Een winkel die in een echte game werkt, is verdeeld tussen het apparaat van de speler en de server. Het apparaat tekent het venster en zegt "ik wil een zwaard kopen". De server, de enige kant die je kunt vertrouwen, beslist of dat gebeurt. Winkelscripts die "niet werken" of die spelers met cheats kraken, nemen die beslissing vaak aan de verkeerde kant.

De vijf onderdelen van een winkel
OnderdeelWaar het staatWat het doet
ModuleScript ShopCatalogReplicatedStorageItem-id's, namen, prijzen en de Tool die elk item geeft. Beide kanten lezen het.
RemoteFunction BuyItemReplicatedStorage, in de map ShopRemotesBrengt het koopverzoek naar de server en het antwoord terug.
LocalScript ShopClientStarterPlayerScriptsBouwt het winkelvenster en stuurt het item-id als er op een Buy-knop wordt gedrukt.
Script ShopServiceServerScriptServiceControleert het verzoek, schrijft Coins af en geeft de Tool.
De Tools die je verkooptServerStorage, in de map ShopItemsDe originelen die de server kopieert. Niets uit ServerStorage wordt naar spelers gestuurd.
De Explorer als de winkel klaar is
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

Stap 1: Munten en items om te verkopen

De winkel besteedt de waarde Coins in de leaderstats van de speler. Als je de handleiding over het leaderboard hebt gevolgd, heb je die al en kun je dit script overslaan. Voeg anders een Script in ServerScriptService in met de naam Leaderstats. Het geeft iedereen bij de start 200 munten, zodat je aankopen meteen kunt testen.

Script in ServerScriptService met de naam Leaderstats
local Players = game:GetService("Players")

local STARTING_COINS = 200 -- genoeg om de winkel te testen; zet op 0 zodra spelers munten kunnen verdienen

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

Houd maar één leaderstats-script. Twee scripts die elk een leaderstats-map maken, geven elke speler twee mappen, en de winkel kan de verkeerde lezen.

Maak daarna de objecten waar de scripts naar zoeken. Hoofdletters in de namen tellen, dus schrijf ze precies zoals hier.

  1. Beweeg in de Explorer je muis over ReplicatedStorage, klik op de knop + en voeg een Folder in met de naam ShopRemotes. Voeg daarin een RemoteFunction in met de naam BuyItem.
  2. Beweeg je muis over ServerStorage en voeg een Folder in met de naam ShopItems.
  3. Leg in ShopItems een Tool voor elk item, met de namen ClassicSword, Flashlight, GrappleHook en SpeedCoil. Voor een eerste test is één niet-verankerd Part met de naam Handle in de Tool genoeg. Elke Tool die je al hebt werkt ook: geef hem de juiste naam. Wapens die echt schade doen, bouw je met de handleiding over een zwaard of de handleiding over een geweer; in elk staat hoe je het aan de catalogus koppelt.
  4. Selecteer elke Tool en haal het vinkje CanBeDropped weg in het Properties-venster. Staat het aan, dan gooit Backspace de tool in Workspace, en kan elke speler oppakken waar de koper voor betaald heeft.

Je kunt met maar één Tool beginnen. Als de Tool van een item ontbreekt, weigert de server dat item te verkopen en geeft hij een waarschuwing met de naam ervan, dus de speler verliest niets.

Stap 2: Items en prijzen in een catalogus

De catalogus is de enige lijst van alles wat de winkel verkoopt. Het LocalScript leest hem om de kaarten te tekenen, en de server leest hem om de prijzen te vinden, dus een prijs veranderen is één aanpassing op één plek.

Beweeg je muis over ReplicatedStorage, voeg een ModuleScript in, hernoem het naar ShopCatalog en vervang de inhoud door dit:

ModuleScript in ReplicatedStorage met de naam ShopCatalog
export type ShopItem = {
	id: string, -- wordt later opgeslagen in een data store: verander het niet als spelers het item al hebben
	name: string, -- staat op de kaart; mag je veranderen
	price: number, -- in Coins
	description: string,
	toolName: string, -- Tool in ServerStorage.ShopItems die de speler krijgt
}

-- De kaarten verschijnen in deze volgorde
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

-- Geeft het item met dit id terug, of nil als zo'n item niet bestaat
function ShopCatalog.get(id: string): ShopItem?
	return byId[id]
end

-- Attribuut van de Player dat de server op true zet als de speler het item heeft
function ShopCatalog.ownedAttribute(id: string): string
	return "Owns_" .. id
end

return ShopCatalog

Elk item heeft een id en apart een getoonde name. De server legt het id vast als een speler iets heeft, dus "Classic Sword" kun je later hernoemen zonder opgeslagen aankopen te breken. Beschrijvingen zijn alleen tekst op de kaart; wat een Tool doet, bepalen zijn eigen scripts.

Spelers kunnen een ModuleScript in ReplicatedStorage lezen, dus deze prijzen zijn openbaar. Dat is prima: ze staan toch al op de kaarten. Waar het om gaat, is dat de client en de server elk hun eigen kopie van de module draaien, dus een speler die de prijzen op zijn apparaat verandert, verandert niets op de server.

Stap 3: De winkel-GUI bouwen

Dit LocalScript bouwt het hele venster in code: een Shop-knop, een paneel met een scrollend grid van kaarten, een Buy-knop voor elk item in de catalogus, een Coins-teller en een statusregel voor de antwoorden van de server. Omdat alles in code gebeurt, kun je het plakken en op Play drukken. De tabel erna somt elk object op, als je het venster met de hand wilt opbouwen.

  1. Klap in de Explorer StarterPlayer open, beweeg je muis over StarterPlayerScripts en voeg een LocalScript in met de naam ShopClient.
  2. Vervang de inhoud door de code hieronder.
LocalScript in StarterPlayerScripts met de naam ShopClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Wat de module ShopCatalog teruggeeft, zodat de strikte typecontrole de velden controleert die we gebruiken
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: bevat alles wat de winkel op het scherm van de speler tekent
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- de winkel blijft als het personage respawnt

-- Knop aan de linkerrand die de winkel opent en sluit
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)

-- Het winkelvenster: in het midden, verborgen tot de speler het opent
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) -- voorkomt dat het venster enorm wordt op grote schermen
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

-- Hier verschijnen de antwoorden van de server, bijvoorbeeld "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: het gebied dat scrollt als er meer kaarten zijn dan er passen
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() -- begint bij nul; AutomaticCanvasSize rekt het op voor de kaarten
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel

-- UIGridLayout: zet de kaarten in rijen en laat ze doorlopen naar de volgende rij
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..."

		-- We sturen alleen het item-id. De prijs zoekt de server zelf op.
		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)

	-- De server zet dit attribuut als de aankoop gelukt is (of als opgeslagen items geladen zijn)
	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")

-- We tonen de munten van de speler. De echte waarde staat op de server; hier wordt hij alleen weergegeven.
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()

De knoppen gebruiken Activated, niet MouseButton1Click: dat vuurt bij een muisklik, een tik op een telefoon en de knop A of kruisje op een gamepad.

De type-definities bovenaan beschrijven wat ShopCatalog teruggeeft, zodat de strikte typecontrole een tikfout in een veld vangt, zoals item.prise. Als de game draait, veranderen ze niets.

GUI-objecten en belangrijke eigenschappen
ObjectTaak in de winkelBelangrijkste eigenschappen
ScreenGuiBevat alles wat op het scherm getekend wordtResetOnSpawn false, zodat de winkel een respawn overleeft
FrameHet venster en elke itemkaartAnchorPoint 0.5, 0.5 en Position 0.5, 0.5, zodat het venster in het midden staat
UISizeConstraintBegrenst het venster op grote schermenMaxSize 640 bij 460
ScrollingFrameScrollt als er meer kaarten zijn dan er passenCanvasSize 0 en AutomaticCanvasSize Y, zodat het scrollgebied met de kaarten meegroeit
UIGridLayoutZet kaarten in rijen en laat ze doorlopenCellSize 180 bij 200, CellPadding 12, SortOrder LayoutOrder
UICornerRondt hoeken afCornerRadius van 8 tot 14 pixels
UIPaddingBinnenmargesVan 10 tot 12 pixels aan elke kant
TextButtonDe knoppen Shop, sluiten en BuyHet event Activated

Als je het venster met de hand wilt tekenen, bouw je dezelfde objecten in StarterGui met deze eigenschappen, zet je ook daar ResetOnSpawn van de ScreenGui op false en houd je één kaart als sjabloon die het LocalScript voor elk item in de catalogus kloont. Dan vult het script alleen de kaarten en koppelt het de knoppen. De kooplogica in de volgende stap verandert niet.

Als je game begint met een hoofdmenu, staat in die handleiding één regel die je aan ShopClient toevoegt, zodat de Shop-knop pas verschijnt nadat de speler op Play heeft gedrukt. Om de winkel te openen met een gesprek met een verkoper, laat de handleiding over NPC-dialogen zien hoe je een actie OpenShop toevoegt die ShopClient het venster laat openen, terwijl aankopen nog steeds door de servercontroles van de winkel gaan.

Stap 4: Controle en aankoop op de server

Dit Script is de enige plek waar een aankoop kan gebeuren. Het krijgt een item-id, controleert het, zoekt de prijs op, controleert de Coins van de speler, schrijft dan de munten af en geeft de Tool. De Buy-knop krijgt als antwoord true of false en een bericht om te tonen.

Beweeg je muis over ServerScriptService, voeg een Script in met de naam ShopService en plak dit erin:

Script in ServerScriptService met de naam ShopService
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Wat de module ShopCatalog teruggeeft, zodat de strikte typecontrole de velden controleert die we gebruiken
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: de speler kan de tool meteen gebruiken
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack then
		template:Clone().Parent = backpack
	end
	-- StarterGear: Roblox kopieert hem bij elke spawn van het personage opnieuw naar de Backpack
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		template:Clone().Parent = starterGear
	end
end

local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
	-- 1. De client stuurt alleen het item-id, dus het moet een string zijn
	if type(itemId) ~= "string" then
		return false, "That item does not exist."
	end

	-- 2. We negeren dubbelklikken en stromen verzoeken uit 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. We zoeken het item op in de eigen kopie van de catalogus op de server
	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. De prijs komt uit de catalogus en nooit van de client
	if coins.Value < item.price then
		return false, `You need {item.price - coins.Value} more coins.`
	end

	-- 5. Schrijf de munten af en geef daarna het item. Niets hier yieldt, dus twee verzoeken
	-- van dezelfde speler kunnen niet allebei door de controles hierboven komen voordat dit klaar is.
	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)

Bezit wordt bewaard als een attribuut van de Player, bijvoorbeeld Owns_sword. Attributen die de server zet, repliceren naar het apparaat van de speler, dus het LocalScript kan de kaart op "Owned" zetten. Een wijziging die de speler in zijn eigen kopie maakt, bereikt de server niet.

De Tool komt op twee plekken terecht. De kopie in de Backpack verschijnt meteen in de hotbar. De kopie in StarterGear legt Roblox in de nieuwe Backpack elke keer dat het personage spawnt. Zonder die kopie verdwijnt het gekochte item de eerste keer dat de speler doodgaat.

Waarom de client nooit de prijs stuurt

Alles wat op het apparaat van een speler staat, kan die speler veranderen. Cheaters draaien hun eigen code in hun kopie van de game: ze kunnen je LocalScripts lezen, de GUI veranderen en BuyItem:InvokeServer() aanroepen met welke argumenten en hoe vaak ze maar willen. De beveiligingshandleiding van Roblox zegt dat je zowel het type als de waarde controleert van alles wat een remote ontvangt, en het voorbeeld daar is juist een winkel.

Wat er gebeurt als de server de client vertrouwt
Een cheater stuurtAls de server hem zou gelovenWat ShopService doet
Prijs 0Alle items gratisNegeert hem. De prijs komt uit de catalogus.
Prijs -1000Coins.Value -= -1000 geeft hem 1.000 muntenNegeert hem.
NaN als prijsElke vergelijking met NaN is onwaar, dus de controle "niet genoeg munten" slaat nooit aanNegeert hem.
Een id dat niet in de catalogus staat, of een tabel in plaats van een stringFouten in het script, of items die je niet wilde verkopenAntwoordt "That item does not exist."
Honderden verzoeken per secondeBelasting voor de server, en elk gat in de controles slaat honderden keren toeVerwerkt hooguit één verzoek per speler per halve seconde.
Coins die op zijn eigen scherm zijn veranderdAankopen met munten die hij niet heeftZiet het helemaal niet. De server leest alleen zijn eigen waarde van Coins.

Deze regel geldt voor elke remote die je schrijft: stuur wat de speler koos, zoals een item-id of een slotnummer, en nooit wat het kost of wat hij moet krijgen. De handleiding over RemoteEvents behandelt het controleren van remote-argumenten uitgebreider.

Stap 5: De winkel testen

  1. Klik op Play. Links verschijnt een Shop-knop. Open hem en koop Flashlight: Coins dalen met 25, de tool verschijnt in de hotbar en de knop verandert in Owned.
  2. Probeer de Speed Coil, die 300 kost. De statusregel meldt hoeveel munten je nog tekortkomt, en er wordt niets afgeschreven.
  3. Reset je personage via het menu in de game. Flashlight komt terug in de nieuwe Backpack dankzij de kopie in StarterGear.
  4. Om jezelf tijdens het testen munten te geven, klik je op de schakelaar Client/Server en ga je naar Server, zoek je in de Explorer Players, je naam, leaderstats, Coins en verander je de Value in het Properties-venster. Hetzelfde in de Client-modus verandert alleen je eigen scherm, en dat is precies het soort wijziging dat de server negeert.

Antwoordt de knop "The shop did not answer", open dan het Output-venster via het menu Window in Studio en zoek de rode fout van ShopService. Blijft de knop hangen op "Buying...", dan draait ShopService niet of zit hij vast terwijl hij op een object wacht: zie veelvoorkomende fouten.

Een gamepass verkopen voor Robux

Munten zijn je eigen valuta, dus de winkel hierboven beslist zelf over elke aankoop. Wat een speler voor Robux koopt, werkt anders: een gamepass koop je één keer en houd je voor altijd (VIP-bonussen, een vaste tool), en een developer product kun je steeds opnieuw kopen (een pak munten, een level overslaan). Beide lopen via MarketplaceService van Roblox, en de betaling wordt door Roblox afgehandeld, niet door je script.

Twee regels uit deze handleiding gaan mee: start het koopvenster met een knop op de client, en geef de bonus alleen op de server, als Roblox de aankoop heeft bevestigd of de speler de pass al heeft. De handleiding over een gamepass-script bouwt dit helemaal: bezit controleren bij binnenkomst, het koopvenster, bonussen zoals een VIP-deur, en wanneer een developer product beter is dan een pass. Om een prijs te kiezen laat de gratis Robux-commissiecalculator zien hoeveel een pass of developer product je oplevert na het aandeel van Roblox.

Aankopen van spelers opslaan

Alles wat we gebouwd hebben, leeft één sessie: munten en gekochte items worden gereset als de speler vertrekt, tot je ze opslaat in een data store. Om de opslagcode hier niet te herhalen, volg je de DataStore-tutorial (of stap 3 van de handleiding over het leaderboard, daar staat een kortere versie) en houd je rekening met de regels van de winkel:

  • Sla de id's van items op, bijvoorbeeld { "sword", "flashlight" }, in dezelfde tabel als de waarde van Coins, zodat één opslag zowel de bestede munten als het gekochte item vastlegt. Een Tool of andere instance kun je niet in een data store zetten.
  • Als de data geladen zijn, loop je door de opgeslagen id's, sla je de id's over die niet meer in de catalogus staan, zet je elk Owns_-attribuut en geef je de Tool op dezelfde manier als giveTool dat doet. Het winkelvenster werkt zichzelf bij, omdat het naar die attributen luistert.
  • Bezit van een pass hoef je niet op te slaan: UserOwnsGamePassAsync vraagt het aan Roblox elke keer dat de speler binnenkomt.
  • Sla nooit een speler op van wie de data niet geladen zijn, anders kan een mislukte lading zijn aankopen vervangen door een lege lijst.

Veelvoorkomende fouten en oplossingen

Als de winkel zich vreemd gedraagt, controleer dan eerst dit. Open als eerste het Output-venster (menu Window, dan Output): een scriptfout noemt het script en de regel.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("ShopRemotes")'

Het script wacht op een object dat niet onder precies deze naam bestaat. Controleer de spelling en hoofdletters van ShopRemotes, BuyItem, ShopCatalog en ShopItems, en dat ShopItems in ServerStorage staat, niet in ReplicatedStorage. De handleiding over scriptfouten behandelt deze waarschuwing uitgebreid.

De Buy-knop blijft hangen op "Buying..." en antwoordt niet

Niemand op de server heeft BuyItem.OnServerInvoke ingesteld, dus Roblox houdt het verzoek vast tot dat gebeurt. Controleer dat ShopService een Script is, geen LocalScript, en in ServerScriptService staat, en zoek in Output naar een waarschuwing Infinite yield possible van ShopService: die betekent dat het script vastzit terwijl het op ShopCatalog, ShopRemotes of ShopItems wacht.

De Buy-knop meldt "The shop did not answer"

De aanroep naar de server is mislukt in plaats van een antwoord terug te geven. De gebruikelijke oorzaak is een fout in ShopService tijdens het verwerken van het verzoek, dus zoek in Output de rode fout van ShopService: daarin staat de regel.

De knop meldt "This item is not available right now"

De server vond geen Tool met de toolName van dit item in ServerStorage, ShopItems. In Output staat een waarschuwing met de exacte naam waar hij naar zocht.

Ik kocht een tool, maar het personage kan hem niet vasthouden of zit vast

Een Tool moet precies één part met de naam Handle direct erin hebben, en geen van zijn parts mag verankerd zijn. Voor een tool die je niet in de hand hoeft te houden, haal je in plaats daarvan het vinkje RequiresHandle weg.

De munten zijn op mijn scherm minder geworden, maar niet bij de anderen

De aankoop gebeurde in een LocalScript, dus alleen je eigen apparaat veranderde. Verplaats het afschrijven van munten en het geven van de Tool naar een server-Script, zoals in stap 4.

Gekochte items verdwijnen na opnieuw joinen

Er wordt nog niets opgeslagen. Zie aankopen opslaan.

Maken met RoCode

Als je dit niet allemaal met de hand wilt bouwen, kan RoCode het doen in de place die je open hebt. Het is een onafhankelijke AI-agent voor code: je beschrijft een functie in de webchat, en de plugin voor Roblox Studio maakt de scripts, de remote en de GUI in je Explorer, dus je hoeft geen code uit een chatvenster te kopiëren.

Jij typt

Voeg een winkel met munten toe: een Shop-knop die een grid van vier tools opent met prijzen in de Coins uit mijn leaderstats. De server moet de prijs controleren en de tool in de Backpack en StarterGear geven.

RoCode doet
  • Kan je place met Search Scripts en Read Script doorzoeken op bestaande leaderstats en winkelcode, zodat hij jouw Coins-waarde gebruikt in plaats van een tweede toe te voegen
  • Kan een basisvenster bouwen met Build UI: de winkellayout komt met lege kaarten en een LocalScript voor hover-effecten en de knop Close; de kooplogica wordt in aparte scripts geschreven
  • Maakt de RemoteFunction met Create Instance en schrijft het catalogus-ModuleScript, het server-Script en het LocalScript met Create Script
  • Controleert de compilatie van elk script in Studio met Check Script (types controleert hij niet en scripts draait hij niet), en elke batch wijzigingen is een ongedaan-maakpunt in Studio

Passes moet je nog steeds zelf in de Creator Hub maken, omdat RoCode geen passes en developer products kan maken, en de aankopen test je ook zelf: met plugin 3.9 of nieuwer kan RoCode een korte playtest draaien en de fouten lezen, en met plugin 3.9.15 of nieuwer kan zijn testpersonage op de knoppen Shop en Buy drukken, maar hij controleert alleen wat hij zelf besloot te testen. Een winkel komt meestal na de kerngameplay en het opslaan; de stapsgewijze cyclus om een game te maken met RoCode laat zien waar hij past. Hoe RoCode met Studio verbindt.

Veelgestelde vragen

Wat is beter voor een Buy-knop in Roblox: RemoteEvent of RemoteFunction?

Allebei werkt, zolang de server controleert. Met een RemoteFunction kan de knop wachten op het antwoord van de server en dat tonen, daarom gebruikt deze handleiding er een, en ook het winkelvoorbeeld in de beveiligingshandleiding van Roblox gebruikt een RemoteFunction. Roep hem alleen vanaf de client aan: een server die InvokeClient aanroept, kan eeuwig wachten als de client nooit antwoordt. De handleiding over RemoteEvents vergelijkt beide.

Hoe open je de winkel via een NPC in plaats van met een knop?

Zet een ProximityPrompt in een part van de NPC, bijvoorbeeld zijn HumanoidRootPart, luister naar het Triggered-event in een server-Script en stuur die speler een RemoteEvent, zodat het LocalScript het paneel toont. Als je alleen bij de NPC mag kopen, controleer dan ook de afstand tot de NPC in de BuyItem-handler, omdat de client de remote overal vandaan kan aanroepen.

Hoe verkoop je items die je meerdere keren kunt kopen?

Sla voor zulke items de controle "al in bezit" over en geef geen Tool, maar iets wat je kunt tellen, bijvoorbeeld 1 optellen bij een IntValue die drankjes telt. Het opzoeken van de prijs en de muntcontrole laat je zoals ze zijn.

Waarom verdwijnt de winkel als het personage respawnt?

De ResetOnSpawn van de ScreenGui staat op true, de standaardwaarde, dus Roblox verwijdert hem bij een respawn. Zet hem op false, zoals het script in stap 3 doet.

Kan ik een gratis sjabloon voor een winkel-GUI gebruiken?

Ja, elke layout werkt, zolang de Buy-knoppen alleen het item-id sturen en de aankoop zelf in een server-Script zoals ShopService gebeurt. Controleer voordat je een sjabloon gebruikt of er geen munten worden afgeschreven of items worden gegeven in een LocalScript.

Bronnen en verder lezen

Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.

Probeer RoCode in je eigen game.

Elke dag gratis credits, geen creditcard nodig. Installeer de plugin, beschrijf een functie en kijk wat er in Studio verschijnt.