Guide · Spelsystem

Hur gör man en butik i Roblox Studio

En butik i ett Roblox-spel är två uppgifter: ett GUI som visar föremålen och ett serverskript som avgör om köpet blir av. I den här guiden bygger vi båda för en butik med mynt som säljer verktyg, och visar var köp med Robux hör hemma.

Uppdaterad 20 november 202613 min läsningSkriven av

I korthet

Spara föremål och priser i en ModuleScript i ReplicatedStorage, bygg fönstret av ScreenGui, ScrollingFrame och UIGridLayout, och låt varje Buy-knapp anropa en RemoteFunction och bara skicka föremålets id. Sedan hittar ett Script i ServerScriptService själv priset, kontrollerar och drar spelarens Coins och ger föremålet.

  • Låt aldrig klienten skicka priset. Vem som helst kan anropa dina remotes med vilka värden som helst, så servern tar priset från sin egen kopia av katalogen.
  • Ge ett köpt Tool genom att klona det från ServerStorage till spelarens Backpack (för att kunna använda det direkt) och till StarterGear (så att det kommer tillbaka efter respawn).
  • Det som säljs för Robux är passes och developer products, och dem hanterar MarketplaceService. För dem skapar Roblox dessutom en egen Shop, och det är inte samma sak som en butik med mynt.
På den här sidan
  1. Hur det fungerar
  2. 1. Förberedelser
  3. 2. Föremålskatalog
  4. 3. Butikens GUI
  5. 4. Köp på servern
  6. Varför inget pris från klienten
  7. 5. Test
  8. Gamepass
  9. Spara köp
  10. Common errors
  11. Med RoCode
  12. Vanliga frågor
  13. Källor och vidare läsning

Hur en fungerande butik är uppbyggd

IllustrationSpelaren öppnar butiken och köper Flashlight för 25 mynt: Coins sjunker från 200 till 175, knappen byts till Owned, och verktyget dyker upp i hotbaren.

En butik som fungerar i ett riktigt spel är uppdelad mellan spelarens enhet och servern. Enheten ritar fönstret och säger "jag vill köpa ett svärd". Servern, den enda sidan man kan lita på, avgör om det händer. Butiksskript som "inte fungerar" eller som spelare knäcker med fusk fattar ofta det beslutet på fel sida.

Butikens fem delar
DelVar den finnsVad den gör
ModuleScript ShopCatalogReplicatedStorageFöremålens id, namn, priser och det Tool som vart och ett ger. Båda sidor läser den.
RemoteFunction BuyItemReplicatedStorage, i mappen ShopRemotesBär köpförfrågan till servern och svaret tillbaka.
LocalScript ShopClientStarterPlayerScriptsBygger butiksfönstret och skickar föremålets id när en Buy-knapp trycks.
Script ShopServiceServerScriptServiceKontrollerar förfrågan, drar Coins och ger Tool.
Tools som du säljerServerStorage, i mappen ShopItemsOriginalen som servern kopierar. Inget från ServerStorage skickas till spelarna.
Explorer när butiken är klar
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

Steg 1: Mynt och föremål till salu

Butiken spenderar värdet Coins i spelarens leaderstats. Om du har gått igenom guiden om topplistor har du det redan och kan hoppa över det här skriptet. Annars infogar du ett Script i ServerScriptService med namnet Leaderstats. Det ger alla 200 mynt från start, så att köp kan testas direkt.

Script i ServerScriptService med namnet Leaderstats
local Players = game:GetService("Players")

local STARTING_COINS = 200 -- räcker för att testa butiken; sätt 0 när spelarna kan tjäna mynt

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

Ha bara ett leaderstats-skript. Två skript som båda skapar en leaderstats-mapp ger varje spelare två mappar, och butiken kan läsa fel mapp.

Skapa sedan objekten som skripten letar efter. Stora och små bokstäver i namnen spelar roll, så skriv dem exakt som här.

  1. I Explorer, håll muspekaren över ReplicatedStorage, tryck på knappen + och infoga en Folder med namnet ShopRemotes. Infoga inuti den en RemoteFunction med namnet BuyItem.
  2. Håll muspekaren över ServerStorage och infoga en Folder med namnet ShopItems.
  3. Lägg ett Tool per föremål i ShopItems, med namnen ClassicSword, Flashlight, GrappleHook och SpeedCoil. För ett första test räcker det med en enda icke-förankrad Part med namnet Handle i varje Tool. Ett Tool som du redan har fungerar också: ge det rätt namn. Vapen som faktiskt gör skada bygger du med guiden om svärd eller guiden om vapen; i båda står det hur du kopplar dem till katalogen.
  4. Markera varje Tool och avmarkera CanBeDropped i fönstret Properties. När den är markerad släpper Backspace verktyget i Workspace, och vilken spelare som helst kan plocka upp det som köparen har betalat för.

Du kan börja med bara ett Tool. Om ett föremåls Tool saknas vägrar servern att sälja det föremålet och skriver en varning med dess namn, så att inget dras från spelaren.

Steg 2: Föremål och priser i katalogen

Katalogen är den enda listan över allt som butiken säljer. LocalScript läser den för att rita korten, och servern läser den för att hitta priserna, så att ändra ett pris är en ändring på ett ställe.

Håll muspekaren över ReplicatedStorage, infoga en ModuleScript, byt namn på den till ShopCatalog och ersätt innehållet med detta:

ModuleScript i ReplicatedStorage med namnet ShopCatalog
export type ShopItem = {
	id: string, -- sparas senare i datalagret: ändra det inte när spelare redan äger föremålet
	name: string, -- visas på kortet; får ändras
	price: number, -- i Coins
	description: string,
	toolName: string, -- Tool i ServerStorage.ShopItems som spelaren får
}

-- Korten visas i den här ordningen
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

-- Returnerar föremålet med detta id eller nil om det inte finns
function ShopCatalog.get(id: string): ShopItem?
	return byId[id]
end

-- Player-attributet som servern sätter till true när spelaren äger föremålet
function ShopCatalog.ownedAttribute(id: string): string
	return "Owns_" .. id
end

return ShopCatalog

Varje föremål har ett id och ett separat visningsnamn name. Servern sparar just id:t när en spelare äger något, så du kan senare byta namn på "Classic Sword" utan att förstöra sparade köp. Beskrivningarna är bara text på kortet; vad ett Tool gör bestämmer dess egna skript.

Spelare kan läsa en ModuleScript i ReplicatedStorage, så de här priserna är offentliga. Det är okej: de står ju redan på korten. Det viktiga är att klienten och servern kör var sin kopia av modulen, så en spelare som ändrar priserna på sin enhet ändrar ingenting på servern.

Steg 3: Vi bygger butikens GUI

Den här LocalScript bygger hela fönstret i kod: Shop-knappen, en panel med ett scrollbart rutnät av kort, en Buy-knapp för varje föremål i katalogen, en Coins-räknare och en statusrad för serverns svar. Eftersom allt görs i kod kan du klistra in den och trycka på Play. Tabellen efter den listar varje objekt, om du vill lägga upp fönstret för hand.

  1. I Explorer, fäll ut StarterPlayer, håll muspekaren över StarterPlayerScripts och infoga en LocalScript med namnet ShopClient.
  2. Ersätt dess innehåll med koden nedan.
LocalScript i StarterPlayerScripts med namnet ShopClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Vad modulen ShopCatalog returnerar, så att strikt typkontroll kontrollerar fälten vi använder
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: håller allt som butiken ritar på spelarens skärm
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- butiken finns kvar när karaktären respawnar

-- Knappen vid vänsterkanten som öppnar och stänger butiken
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)

-- Butiksfönstret: centrerat, dolt tills spelaren öppnar det
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) -- hindrar fönstret från att bli jättestort på stora skärmar
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

-- Här visas serverns svar, till exempel "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: ytan som scrollar när det finns fler kort än som får plats
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() -- börjar på noll; AutomaticCanvasSize sträcker ut den efter korten
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel

-- UIGridLayout: lägger korten i rader och bryter till nästa rad
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..."

		-- Vi skickar bara föremålets id. Priset hittar servern själv.
		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)

	-- Servern sätter detta attribut när köpet har gått igenom (eller när sparade föremål har laddats)
	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")

-- Vi visar spelarens mynt. Det verkliga värdet finns på servern; här visas det bara.
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()

Knapparna använder Activated, inte MouseButton1Click: den utlöses av ett musklick, en tryckning på mobilen och knappen A eller kryss på en handkontroll.

Definitionerna med type högst upp beskriver vad ShopCatalog returnerar, så att strikt typkontroll fångar ett stavfel i ett fält, till exempel item.prise. När spelet körs ändrar de ingenting.

GUI-objekt och viktiga egenskaper
ObjektUppgift i butikenViktigaste egenskaper
ScreenGuiHåller allt som ritas på skärmenResetOnSpawn false, så att butiken överlever respawn
FrameFönstret och varje föremålskortAnchorPoint 0.5, 0.5 och Position 0.5, 0.5, så att fönstret är centrerat
UISizeConstraintBegränsar fönstret på stora skärmarMaxSize 640 gånger 460
ScrollingFrameScrollar när det finns fler kort än som får platsCanvasSize 0 och AutomaticCanvasSize Y, så att scrollytan växer med korten
UIGridLayoutStäller korten i rader och bryter demCellSize 180 gånger 200, CellPadding 12, SortOrder LayoutOrder
UICornerRundar hörnenCornerRadius från 8 till 14 pixlar
UIPaddingInre marginalerFrån 10 till 12 pixlar på varje sida
TextButtonKnapparna Shop, stäng och BuyHändelsen Activated

Om du vill rita fönstret för hand, bygg samma objekt i StarterGui med de här egenskaperna, sätt även där ResetOnSpawn på ScreenGui till false och behåll ett kort som mall som LocalScript klonar för varje föremål i katalogen. Då fyller skriptet bara i korten och kopplar knapparna. Köplogiken i nästa steg ändras inte.

Om ditt spel börjar med en huvudmeny finns det i den guiden en rad som du ska lägga till i ShopClient, så att Shop-knappen bara visas efter att spelaren har tryckt på Play. För att butiken ska öppnas genom ett samtal med en försäljare visar guiden om NPC-dialoger hur du lägger till handlingen OpenShop, som säger åt ShopClient att öppna fönstret, medan köpen fortfarande går genom butikens serverkontroller.

Steg 4: Kontroll och köp på servern

Det här Script är det enda stället där ett köp kan ske. Det tar emot föremålets id, kontrollerar det, hittar priset, kontrollerar spelarens Coins, drar sedan mynten och ger Tool. Till Buy-knappen svarar det true eller false och ett meddelande att visa.

Håll muspekaren över ServerScriptService, infoga ett Script med namnet ShopService och klistra in detta:

Script i ServerScriptService med namnet ShopService
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Vad modulen ShopCatalog returnerar, så att strikt typkontroll kontrollerar fälten vi använder
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: spelaren kan använda verktyget direkt
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack then
		template:Clone().Parent = backpack
	end
	-- StarterGear: Roblox kopierar det till Backpack igen varje gång karaktären spawnar
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		template:Clone().Parent = starterGear
	end
end

local function onBuyItem(player: Player, itemId: unknown): (boolean, string)
	-- 1. Klienten skickar bara föremålets id, så det måste vara en sträng
	if type(itemId) ~= "string" then
		return false, "That item does not exist."
	end

	-- 2. Vi ignorerar dubbelklick och strömmar av förfrågningar från skript
	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. Vi letar upp föremålet i serverns egen kopia av katalogen
	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. Priset tas från katalogen och aldrig från klienten
	if coins.Value < item.price then
		return false, `You need {item.price - coins.Value} more coins.`
	end

	-- 5. Vi drar mynten och ger sedan föremålet. Inget här lämnar ifrån sig körningen, så två förfrågningar
	-- från samma spelare kan inte båda passera kontrollerna ovan innan detta har körts.
	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)

Ägandet sparas som ett Player-attribut, till exempel Owns_sword. Attribut som servern sätter replikeras till spelarens enhet, så att LocalScript kan byta kortet till "Owned". En ändring som spelaren gör i sin kopia når inte servern.

Tool hamnar på två ställen. Kopian i Backpack dyker direkt upp i hotbaren. Kopian i StarterGear lägger Roblox i en ny Backpack varje gång karaktären spawnar. Utan den försvinner det köpta föremålet första gången spelaren dör.

Varför klienten aldrig skickar priset

Allt som finns på spelarens enhet kan den spelaren ändra. Fuskare kör sin egen kod i sin kopia av spelet: de kan läsa dina LocalScript, ändra GUI:t och anropa BuyItem:InvokeServer() med vilka argument som helst hur många gånger som helst. Roblox säkerhetsguide säger att du ska kontrollera både typ och värde för allt som en remote tar emot, och som exempel används just en butik.

Vad som händer om servern litar på klienten
Fuskaren skickarOm servern trodde på honomVad ShopService gör
Priset 0Alla föremål är gratisIgnorerar det. Priset tas från katalogen.
Priset -1000Coins.Value -= -1000 ger honom 1 000 myntIgnorerar det.
NaN i stället för prisetVarje jämförelse med NaN är falsk, så kontrollen "inte tillräckligt med mynt" slår aldrig tillIgnorerar det.
Ett id som inte finns i katalogen, eller en tabell i stället för en strängFel i skriptet eller föremål som du inte tänkt säljaSvarar "That item does not exist."
Hundratals förfrågningar per sekundBelastning på servern, och varje hål i kontrollerna utlöses hundratals gångerHanterar högst en förfrågan per spelare varje halv sekund.
Coins ändrade på hans egen skärmKöp med mynt som han inte harSer det inte alls. Servern läser bara sitt eget Coins-värde.

Den här regeln gäller varje remote som du skriver: skicka det som spelaren valde, till exempel föremålets id eller platsnumret, och aldrig vad det kostar eller vad han ska få. Guiden om RemoteEvent går igenom kontroll av remote-argument mer i detalj.

Steg 5: Vi testar butiken

  1. Tryck på Play. Till vänster dyker Shop-knappen upp. Öppna den och köp Flashlight: Coins minskar med 25, verktyget dyker upp i hotbaren, och dess knapp byts till Owned.
  2. Prova Speed Coil, som kostar 300. Statusraden skriver hur många mynt som fattas, och ingenting dras.
  3. Återställ karaktären via menyn i spelet. Flashlight kommer tillbaka i den nya Backpack tack vare kopian i StarterGear.
  4. För att ge dig själv mynt under testet, tryck på växlaren Client/Server och byt till Server, leta upp Players, ditt namn, leaderstats, Coins i Explorer och ändra dess Value i fönstret Properties. Samma sak i Client-läge ändrar bara din skärm, och det är precis en sådan ändring som servern ignorerar.

Om knappen svarar "The shop did not answer", öppna fönstret Output via menyn Window i Studio och leta efter ett rött fel från ShopService. Om knappen däremot hänger på "Buying..." körs ShopService inte eller har fastnat i väntan på ett objekt: se vanliga fel.

Sälja en gamepass för Robux

Mynt är din egen valuta, så butiken ovan avgör själv varje köp. Det som spelaren köper för Robux fungerar annorlunda: en gamepass köps en gång och finns kvar för alltid (VIP-bonusar, ett permanent verktyg), medan en developer product kan köpas om och om igen (ett paket mynt, att hoppa över en nivå). Båda går via MarketplaceService från Roblox, och betalningen tas emot av Roblox, inte av ditt skript.

Från den här guiden följer två regler med: starta köpfönstret med en knapp på klienten, och ge bonusen bara på servern, när Roblox har bekräftat köpet eller spelaren redan äger passet. Guiden om gamepass-skript bygger allt det: ägarkontroll vid inloggning, köpfönstret, bonusar som en VIP-dörr och när en developer product passar bättre än ett pass. För att välja pris visar den gratis Robux-avgiftskalkylatorn hur mycket ett pass eller en developer product ger dig efter Roblox andel.

Vi sparar spelarnas köp

Allt vi har gjort lever en session: mynt och köpta föremål nollställs när spelaren lämnar, tills du sparar dem med ett datalager. För att inte upprepa sparkoden här, gå igenom DataStore-guiden (eller steg 3 i guiden om topplistor, där versionen är kortare) och kom ihåg butikens regler:

  • Spara föremålens id, till exempel { "sword", "flashlight" }, i samma tabell som Coins-värdet, så att en sparning skriver både de spenderade mynten och det köpta föremålet. Tool och andra instanser kan inte läggas i ett datalager.
  • När datan har laddats, gå igenom de sparade id:na, hoppa över dem som inte längre finns i katalogen, sätt varje Owns_-attribut och ge Tool på samma sätt som giveTool gör. Butiksfönstret uppdateras av sig självt, eftersom det lyssnar på de attributen.
  • Ägande av ett pass behöver inte sparas: UserOwnsGamePassAsync frågar Roblox varje gång spelaren går in.
  • Spara aldrig en spelare vars data inte laddades, annars kan en misslyckad laddning ersätta hans köp med en tom lista.

Vanliga fel och lösningar

När butiken beter sig konstigt, kontrollera detta först. Öppna först fönstret Output (menyn Window, sedan Output): ett skriptfel anger skriptet och raden.

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

Skriptet väntar på ett objekt som inte finns med exakt det namnet. Kontrollera stavning och versaler i ShopRemotes, BuyItem, ShopCatalog och ShopItems, och att ShopItems ligger i ServerStorage och inte i ReplicatedStorage. Guiden om skriptfel går igenom den här varningen i detalj.

Buy-knappen hänger på "Buying..." och svarar inte

Ingen på servern har satt BuyItem.OnServerInvoke, så Roblox håller kvar förfrågan tills det händer. Se till att ShopService är ett Script, inte en LocalScript, och ligger i ServerScriptService, och leta i Output efter varningen Infinite yield possible från ShopService: den betyder att skriptet har fastnat i väntan på ShopCatalog, ShopRemotes eller ShopItems.

Buy-knappen skriver "The shop did not answer"

Serveranropet kraschade i stället för att returnera ett svar. Den vanliga orsaken är ett fel inuti ShopService medan förfrågan hanteras, så leta upp det röda felet från ShopService i Output: där anges raden.

Knappen skriver "This item is not available right now"

Servern hittade inget Tool med föremålets toolName inuti ServerStorage, ShopItems. I Output finns en varning med det exakta namnet den letade efter.

Jag köpte ett verktyg, men karaktären kan inte hålla det eller fastnar

Ett Tool måste ha exakt en part med namnet Handle direkt inuti sig, och ingen av dess parts får vara förankrad. För ett verktyg som inte behöver hållas i handen, avmarkera i stället RequiresHandle.

Mynten minskade på min skärm men inte för de andra

Köpet skedde i en LocalScript, så bara din enhet ändrades. Flytta dragningen av mynt och utdelningen av Tool till ett serverskript, som i steg 4.

Köpta föremål försvinner när jag går in igen

Än så länge sparas ingenting. Se spara köp.

Gör det med RoCode

Om du inte vill bygga allt det här för hand kan RoCode göra det i din öppna place. Det är en oberoende AI-agent för kod: du beskriver funktionen i dess webbchatt, och dess plugin för Roblox Studio skapar skripten, remoten och GUI:t i din Explorer, så du behöver inte kopiera kod från ett chattfönster.

Du skriver

Lägg till en butik med mynt: en Shop-knapp som öppnar ett rutnät med fyra verktyg med priser i Coins från mina leaderstats. Servern ska kontrollera priset och ge verktyget till Backpack och StarterGear.

RoCode gör
  • Kan gå igenom din place med Search Scripts och Read Script efter befintliga leaderstats och butikskod, så att ditt Coins-värde används i stället för att ett andra läggs till
  • Kan bygga ett fönsterutkast med Build UI: butikslayouten kommer med platshållarkort och en LocalScript för hover-effekter och Close-knappen; köplogiken skrivs i separata skript
  • Skapar RemoteFunction med Create Instance och skriver katalogens ModuleScript, serverns Script och LocalScript med Create Script
  • Kontrollerar att varje skript kompilerar i Studio med Check Script (typer kontrolleras inte och skript körs inte), och varje omgång ändringar är en ångrapunkt i Studio

Passes måste du fortfarande skapa själv i Creator Hub, eftersom RoCode inte kan skapa passes och developer products, och köpen testar också du: med plugin 3.9 eller nyare kan RoCode köra ett kort speltest och läsa felen, och med plugin 3.9.15 eller nyare kan dess testkaraktär trycka på knapparna Shop och Buy, men den kontrollerar bara det som den själv bestämde sig för att testa. En butik kommer oftast efter det grundläggande spelandet och sparningen; steg-för-steg-loopen för att skapa ett spel med RoCode visar var den hör hemma. Hur RoCode ansluter till Studio.

Vanliga frågor

Vad är bäst för en Buy-knapp i Roblox: RemoteEvent eller RemoteFunction?

Båda fungerar, så länge servern kontrollerar. En RemoteFunction låter knappen vänta på serverns svar och visa det, därför används den i guiden, och i Roblox säkerhetsguide använder butiksexemplet också en RemoteFunction. Anropa den bara från klienten: en server som anropar InvokeClient kan vänta för evigt om klienten aldrig svarar. Guiden om RemoteEvent jämför båda alternativen.

Hur öppnar man butiken via en NPC i stället för en knapp?

Lägg en ProximityPrompt i någon av NPC:ns parts, till exempel dess HumanoidRootPart, lyssna på dess händelse Triggered i ett serverskript och skicka en RemoteEvent till den spelaren så att LocalScript visar panelen. Om man bara ska kunna köpa nära NPC:n, kontrollera även avståndet till NPC:n inuti BuyItem-hanteraren, eftersom klienten kan anropa remoten varifrån som helst.

Hur säljer man föremål som kan köpas flera gånger?

För sådana föremål, hoppa över kontrollen "äger redan" och ge inte ett Tool utan något som kan räknas, till exempel lägg till 1 till en IntValue som räknar drycker. Prisuppslaget och myntkontrollen behåller du som de är.

Varför försvinner butiken när karaktären respawnar?

Dess ScreenGui har ResetOnSpawn satt till true, vilket är standardvärdet, så Roblox tar bort den vid respawn. Sätt den till false, som skriptet i steg 3 gör.

Kan man använda en gratis mall för butiks-GUI?

Ja, vilken layout som helst fungerar, så länge dess Buy-knappar bara skickar föremålets id och själva köpet sker i ett serverskript som ShopService. Innan du tar en mall, kontrollera att mynt inte dras eller föremål delas ut i en LocalScript.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.