ट्यूटोरियल · गेम सिस्टम

Roblox Studio में शॉप कैसे बनाएं

Roblox गेम में शॉप के दो काम हैं: एक GUI जो आइटम दिखाता है, और एक सर्वर स्क्रिप्ट जो तय करती है कि ख़रीद होगी या नहीं। इस गाइड में हम टूल बेचने वाली सिक्कों की शॉप के लिए दोनों बनाते हैं, और दिखाते हैं कि Robux से ख़रीदारी कहाँ फ़िट होती है।

अपडेट किया गया 20 नवंबर 202614 मिनट में पढ़ेंलेखक:

संक्षेप में

आइटम और कीमतें ReplicatedStorage के ModuleScript में रखें, विंडो ScreenGui, ScrollingFrame और UIGridLayout से बनाएँ, और हर Buy बटन सिर्फ़ आइटम की id भेजकर एक RemoteFunction कॉल करे। इसके बाद ServerScriptService की Script ख़ुद कीमत ढूँढती है, प्लेयर के Coins जाँचती और काटती है और आइटम देती है।

  • क्लाइंट को कभी कीमत भेजने न दें। कोई भी आपके remotes को किसी भी वैल्यू के साथ कॉल कर सकता है, इसलिए सर्वर कीमत कैटलॉग की अपनी कॉपी से लेता है।
  • ख़रीदा गया Tool ServerStorage से क्लोन करके प्लेयर के Backpack में (तुरंत इस्तेमाल के लिए) और StarterGear में (ताकि respawn के बाद लौट आए) दें।
  • जो Robux से बिकता है, वह passes और developer products हैं, और उनके साथ MarketplaceService काम करता है। उनके लिए Roblox ख़ुद भी एक Shop बनाता है, और वह सिक्कों वाली शॉप जैसा नहीं है।
इस पेज पर
  1. यह कैसे बनी है
  2. 1. तैयारी
  3. 2. आइटम कैटलॉग
  4. 3. शॉप GUI
  5. 4. सर्वर पर ख़रीद
  6. क्लाइंट से कीमत क्यों नहीं
  7. 5. टेस्ट
  8. गेमपास
  9. ख़रीदारी सेव करना
  10. Common errors
  11. RoCode के साथ
  12. अक्सर पूछे जाने वाले सवाल
  13. स्रोत और आगे पढ़ें

काम करने वाली शॉप कैसे बनी होती है

उदाहरणप्लेयर शॉप खोलकर 25 सिक्कों में Flashlight ख़रीदता है: Coins 200 से 175 हो जाते हैं, बटन Owned बन जाता है, और टूल हॉटबार में आ जाता है।

असली गेम में काम करने वाली शॉप प्लेयर के डिवाइस और सर्वर के बीच बँटी होती है। डिवाइस विंडो बनाता है और कहता है "मुझे तलवार ख़रीदनी है"। सर्वर, इकलौता पक्ष जिस पर भरोसा किया जा सकता है, तय करता है कि यह होगा या नहीं। शॉप की जो स्क्रिप्ट "काम नहीं करतीं" या जिन्हें प्लेयर cheats से तोड़ देते हैं, वे अक्सर यह फ़ैसला ग़लत पक्ष पर लेती हैं।

शॉप के पाँच हिस्से
हिस्साकहाँ हैक्या करता है
ModuleScript ShopCatalogReplicatedStorageआइटम की ids, नाम, कीमतें और हर एक जो Tool देता है। दोनों पक्ष इसे पढ़ते हैं।
RemoteFunction BuyItemReplicatedStorage, ShopRemotes फ़ोल्डर मेंख़रीद का अनुरोध सर्वर तक और जवाब वापस ले जाता है।
LocalScript ShopClientStarterPlayerScriptsशॉप की विंडो बनाती है और Buy बटन दबने पर आइटम की id भेजती है।
Script ShopServiceServerScriptServiceअनुरोध जाँचती है, Coins काटती है और Tool देती है।
जो Tools आप बेचते हैंServerStorage, ShopItems फ़ोल्डर मेंओरिजिनल, जिन्हें सर्वर कॉपी करता है। ServerStorage से कुछ भी प्लेयर को नहीं भेजा जाता।
शॉप तैयार होने पर Explorer
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

स्टेप 1: सिक्के और बेचने के लिए आइटम

शॉप प्लेयर के leaderstats में Coins वैल्यू ख़र्च करती है। अगर आपने लीडरबोर्ड गाइड पूरी की है, तो यह आपके पास पहले से है, और यह स्क्रिप्ट छोड़ सकते हैं। वरना ServerScriptService में Leaderstats नाम की Script डालें। यह शुरुआत में हर किसी को 200 सिक्के देती है, ताकि ख़रीदारी तुरंत टेस्ट की जा सके।

Script स्थान: ServerScriptService नाम: Leaderstats
local Players = game:GetService("Players")

local STARTING_COINS = 200 -- शॉप टेस्ट करने के लिए काफ़ी; जब प्लेयर सिक्के कमा सकें, तब 0 करें

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

leaderstats की सिर्फ़ एक स्क्रिप्ट रखें। दो स्क्रिप्ट, जिनमें से हर एक leaderstats फ़ोल्डर बनाती है, हर प्लेयर को दो फ़ोल्डर दे देती हैं, और शॉप ग़लत वाला पढ़ सकती है।

आगे वे ऑब्जेक्ट बनाएँ जिन्हें स्क्रिप्ट ढूँढती हैं। नामों में छोटे-बड़े अक्षर मायने रखते हैं, इसलिए उन्हें ठीक वैसे लिखें जैसे यहाँ हैं।

  1. Explorer में ReplicatedStorage पर कर्सर ले जाएँ, + बटन दबाएँ और ShopRemotes नाम का Folder डालें। उसके अंदर BuyItem नाम का RemoteFunction डालें।
  2. ServerStorage पर कर्सर ले जाएँ और ShopItems नाम का Folder डालें।
  3. ShopItems में हर आइटम के लिए एक Tool रखें, जिनके नाम ClassicSword, Flashlight, GrappleHook और SpeedCoil हों। पहले टेस्ट के लिए Tool में Handle नाम का एक बिना Anchored वाला Part काफ़ी है। आपके पास पहले से मौजूद कोई भी Tool भी चलेगा: उसे सही नाम दे दें। असली डैमेज देने वाला हथियार तलवार गाइड या गन गाइड से बनाएँ; हर एक में लिखा है कि उसे कैटलॉग से कैसे जोड़ें।
  4. हर Tool चुनें और Properties विंडो में CanBeDropped का टिक हटाएँ। जब यह चालू हो, Backspace दबाने से टूल Workspace में गिर जाता है, और कोई भी प्लेयर वह उठा सकता है जिसके लिए ख़रीदार ने पैसे दिए।

आप सिर्फ़ एक Tool से भी शुरू कर सकते हैं। अगर किसी आइटम का Tool नहीं है, तो सर्वर वह आइटम बेचने से मना कर देता है और उसके नाम के साथ चेतावनी लिखता है, इसलिए प्लेयर से कुछ नहीं कटता।

स्टेप 2: कैटलॉग में आइटम और कीमतें

कैटलॉग शॉप में बिकने वाली हर चीज़ की इकलौती लिस्ट है। LocalScript कार्ड बनाने के लिए इसे पढ़ती है, और सर्वर कीमतें ढूँढने के लिए, इसलिए कीमत बदलना एक जगह एक बदलाव है।

ReplicatedStorage पर कर्सर ले जाएँ, एक ModuleScript डालें, उसका नाम ShopCatalog करें और उसकी सामग्री इससे बदल दें:

ModuleScript स्थान: ReplicatedStorage नाम: ShopCatalog
export type ShopItem = {
	id: string, -- बाद में data store में सेव होता है: जब प्लेयर के पास आइटम हो जाए, तो इसे न बदलें
	name: string, -- कार्ड पर दिखता है; बदल सकते हैं
	price: number, -- Coins में
	description: string,
	toolName: string, -- ServerStorage.ShopItems का Tool, जो प्लेयर को मिलता है
}

-- कार्ड इसी क्रम में दिखते हैं
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

-- इस id वाला आइटम लौटाता है, या nil अगर ऐसा आइटम नहीं है
function ShopCatalog.get(id: string): ShopItem?
	return byId[id]
end

-- Player का attribute, जिसे सर्वर true करता है जब आइटम प्लेयर के पास हो
function ShopCatalog.ownedAttribute(id: string): string
	return "Owns_" .. id
end

return ShopCatalog

हर आइटम की एक id और अलग से दिखने वाला name है। जब प्लेयर के पास कुछ होता है, तो सर्वर id ही लिखता है, इसलिए "Classic Sword" का नाम बाद में बदला जा सकता है, सेव की गई ख़रीदारी तोड़े बिना। विवरण सिर्फ़ कार्ड का टेक्स्ट हैं; Tool क्या करता है, यह उसकी अपनी स्क्रिप्ट तय करती हैं।

प्लेयर ReplicatedStorage का ModuleScript पढ़ सकते हैं, इसलिए ये कीमतें सार्वजनिक हैं। यह ठीक है: वे वैसे भी कार्ड पर लिखी हैं। ज़रूरी यह है कि क्लाइंट और सर्वर मॉड्यूल की अपनी-अपनी कॉपी चलाते हैं, इसलिए जिस प्लेयर ने अपने डिवाइस पर कीमतें बदलीं, वह सर्वर पर कुछ नहीं बदलता।

स्टेप 3: शॉप का GUI बनाना

यह LocalScript पूरी विंडो कोड में बनाती है: Shop बटन, कार्ड के स्क्रॉल होने वाले ग्रिड वाला पैनल, कैटलॉग के हर आइटम के लिए Buy बटन, Coins काउंटर और सर्वर के जवाबों के लिए स्टेटस लाइन। क्योंकि सब कोड से बना है, इसे पेस्ट करके Play दबा सकते हैं। इसके बाद की टेबल में हर ऑब्जेक्ट की लिस्ट है, अगर आप विंडो हाथ से बनाना चाहते हैं।

  1. Explorer में StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ और ShopClient नाम की LocalScript डालें।
  2. उसकी सामग्री नीचे के कोड से बदल दें।
LocalScript स्थान: StarterPlayerScripts नाम: ShopClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- ShopCatalog मॉड्यूल क्या लौटाता है, ताकि strict type checking हमारे इस्तेमाल किए fields जाँचे
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: शॉप प्लेयर की स्क्रीन पर जो कुछ बनाती है, वह सब रखता है
local gui = Instance.new("ScreenGui")
gui.Name = "ShopGui"
gui.ResetOnSpawn = false -- कैरेक्टर के respawn होने पर शॉप बनी रहती है

-- बाएँ किनारे का बटन, जो शॉप खोलता और बंद करता है
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)

-- शॉप की विंडो: बीच में, छिपी हुई जब तक प्लेयर उसे न खोले
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) -- बड़ी स्क्रीन पर विंडो को बहुत बड़ा नहीं होने देता
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

-- यहाँ सर्वर के जवाब दिखते हैं, जैसे "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: वह हिस्सा जो कार्ड के जगह से ज़्यादा होने पर स्क्रॉल होता है
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() -- शून्य से शुरू होता है; AutomaticCanvasSize इसे कार्ड के हिसाब से बढ़ाता है
list.AutomaticCanvasSize = Enum.AutomaticSize.Y
list.Parent = panel

-- UIGridLayout: कार्ड को पंक्तियों में रखता है और अगली पंक्ति में ले जाता है
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..."

		-- सिर्फ़ आइटम की id भेजते हैं। कीमत सर्वर ख़ुद ढूँढता है।
		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)

	-- ख़रीद सफल होने पर (या सेव किए आइटम लोड होने पर) सर्वर यह attribute सेट करता है
	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")

-- प्लेयर के सिक्के दिखाते हैं। असली वैल्यू सर्वर के पास है; यहाँ वह सिर्फ़ दिखाई जाती है।
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()

बटन MouseButton1Click नहीं, Activated इस्तेमाल करते हैं: यह माउस क्लिक, फ़ोन पर टैप और gamepad पर A या cross बटन, सब पर चलता है।

ऊपर की type परिभाषाएँ बताती हैं कि ShopCatalog क्या लौटाता है, ताकि strict type checking किसी field में टाइपो पकड़ ले, जैसे item.prise। गेम चलने पर ये कुछ नहीं बदलतीं।

GUI ऑब्जेक्ट और ज़रूरी प्रॉपर्टी
ऑब्जेक्टशॉप में काममुख्य प्रॉपर्टी
ScreenGuiस्क्रीन पर बनी हर चीज़ रखता हैResetOnSpawn false, ताकि शॉप respawn के बाद बनी रहे
Frameविंडो और हर आइटम कार्डAnchorPoint 0.5, 0.5 और Position 0.5, 0.5, ताकि विंडो बीच में रहे
UISizeConstraintबड़ी स्क्रीन पर विंडो को सीमित करता हैMaxSize 640 गुणा 460
ScrollingFrameजब कार्ड जगह से ज़्यादा हों, तो स्क्रॉल होता हैCanvasSize 0 और AutomaticCanvasSize Y, ताकि स्क्रॉल वाला हिस्सा कार्ड के साथ बढ़े
UIGridLayoutकार्ड को पंक्तियों में रखता है और अगली पंक्ति में ले जाता हैCellSize 180 गुणा 200, CellPadding 12, SortOrder LayoutOrder
UICornerकोने गोल करता हैCornerRadius 8 से 14 पिक्सेल
UIPaddingअंदर की जगहहर तरफ़ 10 से 12 पिक्सेल
TextButtonShop, बंद करने और Buy के बटनActivated इवेंट

अगर विंडो हाथ से बनाना चाहते हैं, तो StarterGui में इन्हीं प्रॉपर्टी के साथ वही ऑब्जेक्ट बनाएँ, वहाँ भी ScreenGui का ResetOnSpawn false करें और एक कार्ड टेम्पलेट के रूप में छोड़ें, जिसे LocalScript कैटलॉग के हर आइटम के लिए क्लोन करे। तब स्क्रिप्ट सिर्फ़ कार्ड भरती है और बटन जोड़ती है। अगले स्टेप का ख़रीद लॉजिक नहीं बदलता।

अगर आपका गेम मेन मेन्यू से शुरू होता है, तो उस गाइड में ShopClient में जोड़ने के लिए एक लाइन है, ताकि Shop बटन प्लेयर के Play दबाने के बाद ही दिखे। बेचने वाले से बात करके शॉप खुले, इसके लिए NPC डायलॉग गाइड दिखाती है कि OpenShop action कैसे जोड़ें, जो ShopClient को विंडो खोलने को कहता है, और ख़रीदारी पहले की तरह शॉप की सर्वर जाँच से गुज़रती है।

स्टेप 4: सर्वर पर जाँच और ख़रीद

यह Script इकलौती जगह है जहाँ ख़रीद हो सकती है। यह आइटम की id लेती है, उसे जाँचती है, कीमत ढूँढती है, प्लेयर के Coins जाँचती है, फिर सिक्के काटती है और Tool देती है। Buy बटन को यह true या false और दिखाने के लिए एक मैसेज लौटाती है।

ServerScriptService पर कर्सर ले जाएँ, ShopService नाम की Script डालें और उसमें यह पेस्ट करें:

Script स्थान: ServerScriptService नाम: ShopService
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- ShopCatalog मॉड्यूल क्या लौटाता है, ताकि strict type checking हमारे इस्तेमाल किए fields जाँचे
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: प्लेयर टूल तुरंत इस्तेमाल कर सकता है
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack then
		template:Clone().Parent = backpack
	end
	-- StarterGear: Roblox हर बार कैरेक्टर आने पर इसे फिर से 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. क्लाइंट सिर्फ़ आइटम की id भेजता है, इसलिए यह string होनी चाहिए
	if type(itemId) ~= "string" then
		return false, "That item does not exist."
	end

	-- 2. डबल क्लिक और स्क्रिप्ट से आने वाले अनुरोधों की बौछार नज़रअंदाज़ करते हैं
	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. सर्वर पर कैटलॉग की अपनी कॉपी में आइटम ढूँढते हैं
	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. कीमत कैटलॉग से ली जाती है, क्लाइंट से कभी नहीं
	if coins.Value < item.price then
		return false, `You need {item.price - coins.Value} more coins.`
	end

	-- 5. सिक्के काटते हैं, फिर आइटम देते हैं। यहाँ कुछ भी yield नहीं करता, इसलिए एक ही प्लेयर के दो
	-- अनुरोध इसके पूरा होने से पहले ऊपर की जाँच दोनों पास नहीं कर सकते।
	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)

मालिकाना Player के attribute के रूप में रखा जाता है, जैसे Owns_sword। सर्वर के सेट किए attributes प्लेयर के डिवाइस तक replicate होते हैं, इसलिए LocalScript कार्ड को "Owned" पर बदल सकती है। प्लेयर अपनी कॉपी में जो बदलाव करता है, वह सर्वर तक नहीं पहुँचता।

Tool दो जगह जाता है। Backpack वाली कॉपी तुरंत हॉटबार में दिखती है। StarterGear वाली कॉपी को Roblox हर बार कैरेक्टर आने पर नए Backpack में रखता है। इसके बिना ख़रीदा गया आइटम प्लेयर की पहली मौत पर ही ग़ायब हो जाएगा।

क्लाइंट कभी कीमत क्यों नहीं भेजता

प्लेयर के डिवाइस पर जो कुछ है, उसे वह प्लेयर बदल सकता है। Cheaters अपने गेम की कॉपी में अपना कोड चलाते हैं: वे आपकी LocalScript पढ़ सकते हैं, GUI बदल सकते हैं और BuyItem:InvokeServer() को किसी भी argument के साथ जितनी बार चाहें कॉल कर सकते हैं। सुरक्षा पर Roblox की गाइड कहती है कि remote को मिलने वाली हर चीज़ का टाइप और वैल्यू दोनों जाँचें, और उदाहरण के तौर पर वहाँ शॉप ही है।

अगर सर्वर क्लाइंट पर भरोसा करे तो क्या होगा
Cheater भेजता हैअगर सर्वर उस पर भरोसा करताShopService क्या करती है
कीमत 0सारे आइटम मुफ़्तउसे नज़रअंदाज़ करती है। कीमत कैटलॉग से ली जाती है।
कीमत -1000Coins.Value -= -1000 उसे 1,000 सिक्के दे देता हैउसे नज़रअंदाज़ करती है।
कीमत की जगह NaNNaN के साथ हर तुलना false होती है, इसलिए "सिक्के कम हैं" वाली जाँच कभी नहीं चलतीउसे नज़रअंदाज़ करती है।
ऐसी id जो कैटलॉग में नहीं है, या string की जगह tableस्क्रिप्ट में एरर या ऐसे आइटम जिन्हें आप बेचना नहीं चाहते थेजवाब देती है "That item does not exist."
सेकंड में सैकड़ों अनुरोधसर्वर पर बोझ, और जाँच का कोई भी छेद सैकड़ों बार काम करता हैहर प्लेयर का आधे सेकंड में एक से ज़्यादा अनुरोध नहीं संभालती।
अपनी स्क्रीन पर बदले हुए Coinsउन सिक्कों से ख़रीदारी जो उसके पास नहीं हैंइसे देखती ही नहीं। सर्वर सिर्फ़ अपनी Coins वैल्यू पढ़ता है।

यह नियम आपके लिखे हर remote पर लागू होता है: वह भेजें जो प्लेयर ने चुना, जैसे आइटम की id या स्लॉट नंबर, और कभी यह नहीं कि उसकी कीमत क्या है या उसे क्या मिलना चाहिए। RemoteEvent गाइड remote के arguments की जाँच विस्तार से समझाती है।

स्टेप 5: शॉप टेस्ट करना

  1. Play दबाएँ। बाईं ओर Shop बटन आएगा। उसे खोलें और Flashlight ख़रीदें: Coins 25 कम होंगे, टूल हॉटबार में आएगा, और उसका बटन Owned में बदल जाएगा।
  2. Speed Coil आज़माएँ, जिसकी कीमत 300 है। स्टेटस लाइन लिखेगी कि कितने सिक्के और चाहिए, और कुछ नहीं कटेगा।
  3. गेम के अंदर के मेन्यू से कैरेक्टर रीसेट करें। StarterGear वाली कॉपी की वजह से Flashlight नए Backpack में लौट आएगा।
  4. टेस्ट के दौरान ख़ुद को सिक्के देने के लिए Client/Server स्विच दबाकर Server पर जाएँ, Explorer में Players, अपना नाम, leaderstats, Coins ढूँढें और Properties विंडो में उसकी Value बदलें। Client मोड में यही करने से सिर्फ़ आपकी स्क्रीन बदलती है, और यही वह बदलाव है जिसे सर्वर नज़रअंदाज़ करता है।

अगर बटन "The shop did not answer" जवाब देता है, तो Studio के Window मेन्यू से Output विंडो खोलें और ShopService का लाल एरर ढूँढें। अगर बटन "Buying..." पर अटका है, तो ShopService चल नहीं रही या किसी ऑब्जेक्ट के इंतज़ार में अटकी है: आम गलतियाँ देखें।

Robux में गेमपास बेचना

सिक्के आपकी अपनी करेंसी हैं, इसलिए ऊपर वाली शॉप हर ख़रीद ख़ुद तय करती है। प्लेयर Robux से जो ख़रीदता है, वह अलग तरह से काम करता है: गेमपास एक बार ख़रीदा जाता है और हमेशा रहता है (VIP फ़ायदे, स्थायी टूल), और developer product बार-बार ख़रीदा जा सकता है (सिक्कों का पैक, लेवल स्किप)। दोनों Roblox के MarketplaceService से होते हैं, और भुगतान Roblox लेता है, आपकी स्क्रिप्ट नहीं।

इस गाइड से दो नियम आगे जाते हैं: ख़रीद की विंडो क्लाइंट पर बटन से खोलें, और फ़ायदा सिर्फ़ सर्वर पर दें, जब Roblox ने ख़रीद की पुष्टि कर दी हो या pass प्लेयर के पास पहले से हो। गेमपास स्क्रिप्ट गाइड यह पूरा बनाती है: जॉइन करने पर मालिकाना जाँच, ख़रीद की विंडो, VIP दरवाज़े जैसे फ़ायदे और कब pass की जगह developer product लेना बेहतर है। कीमत चुनने के लिए मुफ़्त Robux कमीशन कैलकुलेटर दिखाता है कि Roblox का हिस्सा कटने के बाद pass या developer product से आपको कितना मिलता है।

प्लेयर की ख़रीदारी सेव करना

हमने जो कुछ बनाया, वह एक सेशन तक रहता है: प्लेयर के निकलने पर सिक्के और ख़रीदे आइटम रीसेट हो जाते हैं, जब तक आप उन्हें data store में सेव न करें। सेव करने का कोड यहाँ न दोहराने के लिए DataStore ट्यूटोरियल (या लीडरबोर्ड गाइड का स्टेप 3, वहाँ छोटा वर्ज़न है) पढ़ें और शॉप के नियम याद रखें:

  • आइटम की ids सेव करें, जैसे { "sword", "flashlight" }, उसी टेबल में जिसमें Coins वैल्यू है, ताकि एक सेव ख़र्च हुए सिक्के और ख़रीदा आइटम दोनों लिखे। Tool और दूसरे instances data store में नहीं रखे जा सकते।
  • डेटा लोड होने पर सेव की गई ids पर चलें, जो अब कैटलॉग में नहीं हैं उन्हें छोड़ें, हर Owns_ attribute सेट करें और Tool वैसे ही दें जैसे giveTool देता है। शॉप की विंडो अपने आप अपडेट हो जाएगी, क्योंकि वह इन attributes को सुनती है।
  • pass का मालिकाना सेव करने की ज़रूरत नहीं: UserOwnsGamePassAsync हर बार प्लेयर के आने पर Roblox से पूछता है।
  • कभी ऐसे प्लेयर को सेव न करें जिसका डेटा लोड नहीं हुआ, वरना फ़ेल हुआ लोड उसकी ख़रीदारी को ख़ाली लिस्ट से बदल सकता है।

आम गलतियाँ और उनके हल

जब शॉप अजीब बर्ताव करे, तो पहले ये देखें। सबसे पहले Output विंडो खोलें (Window मेन्यू, फिर Output): स्क्रिप्ट का एरर स्क्रिप्ट और लाइन बताता है।

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

स्क्रिप्ट ऐसे ऑब्जेक्ट का इंतज़ार कर रही है जो इस सटीक नाम से नहीं है। ShopRemotes, BuyItem, ShopCatalog और ShopItems की स्पेलिंग और बड़े अक्षर जाँचें, और देखें कि ShopItems, ServerStorage में है, ReplicatedStorage में नहीं। स्क्रिप्ट एरर गाइड इस चेतावनी को विस्तार से समझाती है।

Buy बटन "Buying..." पर अटका है और जवाब नहीं देता

सर्वर पर किसी ने BuyItem.OnServerInvoke सेट नहीं किया, इसलिए Roblox अनुरोध को तब तक रोके रखता है जब तक ऐसा न हो। पक्का करें कि ShopService एक Script है, LocalScript नहीं, और ServerScriptService में है, और Output में ShopService की Infinite yield possible चेतावनी ढूँढें: इसका मतलब है कि स्क्रिप्ट ShopCatalog, ShopRemotes या ShopItems के इंतज़ार में अटकी है।

Buy बटन "The shop did not answer" लिखता है

सर्वर की कॉल ने जवाब लौटाने के बजाय फ़ेल कर दिया। आम वजह अनुरोध संभालते समय ShopService के अंदर का एरर है, इसलिए Output में ShopService का लाल एरर ढूँढें: उसमें लाइन बताई गई है।

बटन "This item is not available right now" लिखता है

सर्वर को ServerStorage, ShopItems के अंदर इस आइटम के toolName वाला Tool नहीं मिला। Output में उस सटीक नाम के साथ चेतावनी है जिसे वह ढूँढ रहा था।

मैंने टूल ख़रीदा, लेकिन कैरेक्टर उसे पकड़ नहीं पाता या अटक जाता है

Tool के ठीक अंदर Handle नाम का ठीक एक पार्ट होना चाहिए, और उसका कोई भी पार्ट Anchored नहीं होना चाहिए। जिस टूल को हाथ में पकड़ने की ज़रूरत नहीं, उसके लिए इसके बजाय RequiresHandle का टिक हटाएँ।

मेरी स्क्रीन पर सिक्के कम हुए, लेकिन बाक़ी लोगों के लिए नहीं

ख़रीद LocalScript में हुई, इसलिए सिर्फ़ आपका डिवाइस बदला। सिक्के काटना और Tool देना सर्वर Script में ले जाएँ, जैसे स्टेप 4 में।

दोबारा जॉइन करने के बाद ख़रीदे आइटम ग़ायब हो जाते हैं

अभी कुछ भी सेव नहीं होता। देखें ख़रीदारी सेव करना।

RoCode से बनाएँ

अगर यह सब हाथ से नहीं बनाना चाहते, तो RoCode इसे आपके खुले place में बना सकता है। यह कोड के लिए एक स्वतंत्र AI एजेंट है: आप इसकी वेब चैट में फ़ीचर बताते हैं, और इसका Roblox Studio प्लगइन आपके Explorer में स्क्रिप्ट, remote और GUI बनाता है, इसलिए चैट विंडो से कोड कॉपी करने की ज़रूरत नहीं।

आप लिखते हैं

सिक्कों वाली शॉप जोड़ो: एक Shop बटन जो चार टूल का ग्रिड खोले, कीमतें मेरे leaderstats के Coins में हों। सर्वर कीमत जाँचे और टूल Backpack और StarterGear में दे।

RoCode करता है
  • Search Scripts और Read Script से आपका place देखकर पहले से मौजूद leaderstats और शॉप का कोड ढूँढ सकता है, ताकि दूसरी वैल्यू जोड़ने के बजाय आपकी Coins वैल्यू इस्तेमाल करे
  • Build UI से विंडो का ढाँचा बना सकता है: शॉप लेआउट में placeholder कार्ड और hover इफ़ेक्ट और Close बटन के लिए LocalScript आती है; ख़रीद का लॉजिक अलग स्क्रिप्ट में लिखा जाता है
  • Create Instance से RemoteFunction बनाता है और Create Script से कैटलॉग का ModuleScript, सर्वर Script और LocalScript लिखता है
  • Studio में Check Script से हर स्क्रिप्ट का compile जाँचता है (यह टाइप नहीं जाँचता और स्क्रिप्ट नहीं चलाता), और बदलावों का हर समूह Studio में एक undo पॉइंट है

Passes आपको फिर भी Creator Hub में ख़ुद बनाने होंगे, क्योंकि RoCode passes और developer products नहीं बना सकता, और ख़रीदारी भी आप ही टेस्ट करते हैं: प्लगइन 3.9 या नए के साथ RoCode एक छोटा playtest चलाकर एरर पढ़ सकता है, और प्लगइन 3.9.15 या नए के साथ इसका टेस्ट कैरेक्टर Shop और Buy बटन दबा सकता है, लेकिन यह सिर्फ़ वही जाँचता है जो इसने ख़ुद टेस्ट करना तय किया। शॉप आमतौर पर मुख्य गेमप्ले और सेविंग के बाद आती है; RoCode के साथ स्टेप बाय स्टेप गेम बनाने का चक्र दिखाता है कि इसकी जगह कहाँ है। RoCode Studio से कैसे जुड़ता है।

अक्सर पूछे जाने वाले सवाल

Roblox में Buy बटन के लिए क्या बेहतर है: RemoteEvent या RemoteFunction?

दोनों चलेंगे, अगर जाँच सर्वर करे। RemoteFunction से बटन सर्वर के जवाब का इंतज़ार करके उसे दिखा सकता है, इसलिए यह गाइड उसे इस्तेमाल करती है, और सुरक्षा पर Roblox की गाइड में शॉप का उदाहरण भी RemoteFunction पर है। इसे सिर्फ़ क्लाइंट से कॉल करें: InvokeClient कॉल करने वाला सर्वर हमेशा के लिए इंतज़ार कर सकता है, अगर क्लाइंट कभी जवाब न दे। RemoteEvent गाइड दोनों विकल्पों की तुलना करती है।

शॉप बटन के बजाय NPC से कैसे खोलें?

NPC के किसी पार्ट में, जैसे उसके HumanoidRootPart में, एक ProximityPrompt रखें, सर्वर Script में उसका Triggered इवेंट सुनें और उस प्लेयर को RemoteEvent भेजें, ताकि LocalScript पैनल दिखाए। अगर ख़रीदारी सिर्फ़ NPC के पास हो सकती है, तो BuyItem handler के अंदर NPC से दूरी भी जाँचें, क्योंकि क्लाइंट remote को कहीं से भी कॉल कर सकता है।

ऐसे आइटम कैसे बेचें जो कई बार ख़रीदे जा सकें?

ऐसे आइटम के लिए "पहले से है" वाली जाँच छोड़ दें और Tool के बजाय कुछ ऐसा दें जिसे गिना जा सके, जैसे potions गिनने वाली IntValue में 1 जोड़ें। कीमत ढूँढना और सिक्कों की जाँच जैसी हैं वैसी रहने दें।

कैरेक्टर के respawn होने पर शॉप क्यों ग़ायब हो जाती है?

उसके ScreenGui का ResetOnSpawn true है, जो डिफ़ॉल्ट वैल्यू है, इसलिए Roblox respawn पर उसे हटा देता है। इसे false करें, जैसे स्टेप 3 की स्क्रिप्ट करती है।

क्या शॉप GUI का मुफ़्त टेम्पलेट ले सकते हैं?

हाँ, कोई भी लेआउट चलेगा, अगर उसके Buy बटन सिर्फ़ आइटम की id भेजें और ख़रीद ख़ुद ShopService जैसी सर्वर Script में हो। टेम्पलेट लेने से पहले जाँचें कि कहीं LocalScript में सिक्के तो नहीं कटते या आइटम तो नहीं दिए जाते।

स्रोत और आगे पढ़ें

कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।

अपने गेम में RoCode आज़माएँ।

हर दिन मुफ़्त क्रेडिट, कार्ड की ज़रूरत नहीं। प्लगइन इंस्टॉल करें, फ़ीचर बताएँ और देखें कि Studio में क्या बना।