संक्षेप में
आइटम और कीमतें ReplicatedStorage के ModuleScript में रखें, विंडो ScreenGui, ScrollingFrame और UIGridLayout से बनाएँ, और हर Buy बटन सिर्फ़ आइटम की id भेजकर एक RemoteFunction कॉल करे। इसके बाद ServerScriptService की Script ख़ुद कीमत ढूँढती है, प्लेयर के Coins जाँचती और काटती है और आइटम देती है।
- क्लाइंट को कभी कीमत भेजने न दें। कोई भी आपके remotes को किसी भी वैल्यू के साथ कॉल कर सकता है, इसलिए सर्वर कीमत कैटलॉग की अपनी कॉपी से लेता है।
- ख़रीदा गया Tool ServerStorage से क्लोन करके प्लेयर के Backpack में (तुरंत इस्तेमाल के लिए) और StarterGear में (ताकि respawn के बाद लौट आए) दें।
- जो Robux से बिकता है, वह passes और developer products हैं, और उनके साथ MarketplaceService काम करता है। उनके लिए Roblox ख़ुद भी एक Shop बनाता है, और वह सिक्कों वाली शॉप जैसा नहीं है।
इस पेज पर
काम करने वाली शॉप कैसे बनी होती है
असली गेम में काम करने वाली शॉप प्लेयर के डिवाइस और सर्वर के बीच बँटी होती है। डिवाइस विंडो बनाता है और कहता है "मुझे तलवार ख़रीदनी है"। सर्वर, इकलौता पक्ष जिस पर भरोसा किया जा सकता है, तय करता है कि यह होगा या नहीं। शॉप की जो स्क्रिप्ट "काम नहीं करतीं" या जिन्हें प्लेयर cheats से तोड़ देते हैं, वे अक्सर यह फ़ैसला ग़लत पक्ष पर लेती हैं।
| हिस्सा | कहाँ है | क्या करता है |
|---|---|---|
ModuleScript ShopCatalog | ReplicatedStorage | आइटम की ids, नाम, कीमतें और हर एक जो Tool देता है। दोनों पक्ष इसे पढ़ते हैं। |
RemoteFunction BuyItem | ReplicatedStorage, ShopRemotes फ़ोल्डर में | ख़रीद का अनुरोध सर्वर तक और जवाब वापस ले जाता है। |
LocalScript ShopClient | StarterPlayerScripts | शॉप की विंडो बनाती है और Buy बटन दबने पर आइटम की id भेजती है। |
Script ShopService | ServerScriptService | अनुरोध जाँचती है, Coins काटती है और Tool देती है। |
| जो Tools आप बेचते हैं | ServerStorage, ShopItems फ़ोल्डर में | ओरिजिनल, जिन्हें सर्वर कॉपी करता है। ServerStorage से कुछ भी प्लेयर को नहीं भेजा जाता। |
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 सिक्के देती है, ताकि ख़रीदारी तुरंत टेस्ट की जा सके।
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 फ़ोल्डर बनाती है, हर प्लेयर को दो फ़ोल्डर दे देती हैं, और शॉप ग़लत वाला पढ़ सकती है।
आगे वे ऑब्जेक्ट बनाएँ जिन्हें स्क्रिप्ट ढूँढती हैं। नामों में छोटे-बड़े अक्षर मायने रखते हैं, इसलिए उन्हें ठीक वैसे लिखें जैसे यहाँ हैं।
- Explorer में ReplicatedStorage पर कर्सर ले जाएँ, + बटन दबाएँ और
ShopRemotesनाम का Folder डालें। उसके अंदरBuyItemनाम का RemoteFunction डालें। - ServerStorage पर कर्सर ले जाएँ और
ShopItemsनाम का Folder डालें। - ShopItems में हर आइटम के लिए एक Tool रखें, जिनके नाम
ClassicSword,Flashlight,GrappleHookऔरSpeedCoilहों। पहले टेस्ट के लिए Tool मेंHandleनाम का एक बिना Anchored वाला Part काफ़ी है। आपके पास पहले से मौजूद कोई भी Tool भी चलेगा: उसे सही नाम दे दें। असली डैमेज देने वाला हथियार तलवार गाइड या गन गाइड से बनाएँ; हर एक में लिखा है कि उसे कैटलॉग से कैसे जोड़ें। - हर Tool चुनें और Properties विंडो में CanBeDropped का टिक हटाएँ। जब यह चालू हो, Backspace दबाने से टूल Workspace में गिर जाता है, और कोई भी प्लेयर वह उठा सकता है जिसके लिए ख़रीदार ने पैसे दिए।
आप सिर्फ़ एक Tool से भी शुरू कर सकते हैं। अगर किसी आइटम का Tool नहीं है, तो सर्वर वह आइटम बेचने से मना कर देता है और उसके नाम के साथ चेतावनी लिखता है, इसलिए प्लेयर से कुछ नहीं कटता।
स्टेप 2: कैटलॉग में आइटम और कीमतें
कैटलॉग शॉप में बिकने वाली हर चीज़ की इकलौती लिस्ट है। LocalScript कार्ड बनाने के लिए इसे पढ़ती है, और सर्वर कीमतें ढूँढने के लिए, इसलिए कीमत बदलना एक जगह एक बदलाव है।
ReplicatedStorage पर कर्सर ले जाएँ, एक ModuleScript डालें, उसका नाम 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 दबा सकते हैं। इसके बाद की टेबल में हर ऑब्जेक्ट की लिस्ट है, अगर आप विंडो हाथ से बनाना चाहते हैं।
- Explorer में StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ और
ShopClientनाम की LocalScript डालें। - उसकी सामग्री नीचे के कोड से बदल दें।
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। गेम चलने पर ये कुछ नहीं बदलतीं।
| ऑब्जेक्ट | शॉप में काम | मुख्य प्रॉपर्टी |
|---|---|---|
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 पिक्सेल |
TextButton | Shop, बंद करने और 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 डालें और उसमें यह पेस्ट करें:
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 | सारे आइटम मुफ़्त | उसे नज़रअंदाज़ करती है। कीमत कैटलॉग से ली जाती है। |
| कीमत -1000 | Coins.Value -= -1000 उसे 1,000 सिक्के दे देता है | उसे नज़रअंदाज़ करती है। |
कीमत की जगह NaN | NaN के साथ हर तुलना false होती है, इसलिए "सिक्के कम हैं" वाली जाँच कभी नहीं चलती | उसे नज़रअंदाज़ करती है। |
| ऐसी id जो कैटलॉग में नहीं है, या string की जगह table | स्क्रिप्ट में एरर या ऐसे आइटम जिन्हें आप बेचना नहीं चाहते थे | जवाब देती है "That item does not exist." |
| सेकंड में सैकड़ों अनुरोध | सर्वर पर बोझ, और जाँच का कोई भी छेद सैकड़ों बार काम करता है | हर प्लेयर का आधे सेकंड में एक से ज़्यादा अनुरोध नहीं संभालती। |
| अपनी स्क्रीन पर बदले हुए Coins | उन सिक्कों से ख़रीदारी जो उसके पास नहीं हैं | इसे देखती ही नहीं। सर्वर सिर्फ़ अपनी Coins वैल्यू पढ़ता है। |
यह नियम आपके लिखे हर remote पर लागू होता है: वह भेजें जो प्लेयर ने चुना, जैसे आइटम की id या स्लॉट नंबर, और कभी यह नहीं कि उसकी कीमत क्या है या उसे क्या मिलना चाहिए। RemoteEvent गाइड remote के arguments की जाँच विस्तार से समझाती है।
स्टेप 5: शॉप टेस्ट करना
- Play दबाएँ। बाईं ओर Shop बटन आएगा। उसे खोलें और Flashlight ख़रीदें: Coins 25 कम होंगे, टूल हॉटबार में आएगा, और उसका बटन Owned में बदल जाएगा।
- Speed Coil आज़माएँ, जिसकी कीमत 300 है। स्टेटस लाइन लिखेगी कि कितने सिक्के और चाहिए, और कुछ नहीं कटेगा।
- गेम के अंदर के मेन्यू से कैरेक्टर रीसेट करें। StarterGear वाली कॉपी की वजह से Flashlight नए Backpack में लौट आएगा।
- टेस्ट के दौरान ख़ुद को सिक्के देने के लिए 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 में दे।
- 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 Creator Docs: Securing the client-server boundary (अंग्रेज़ी में). remotes के arguments की जाँच, NaN, rate limiting और गेम के अंदर की शॉप का उदाहरण
- Roblox Creator Docs: Remote events and callbacks (अंग्रेज़ी में). RemoteFunction, InvokeServer, OnServerInvoke और InvokeClient के जोखिम
- Roblox Creator Docs: Passes (अंग्रेज़ी में). passes बनाना और बेचना, UserOwnsGamePassAsync और PromptGamePassPurchaseFinished
- Roblox Creator Docs: Shop (अंग्रेज़ी में). गेम के अंदर का Shop, जिसे Roblox अपने आप बनाता है
- Roblox Creator Docs: Developer Products (अंग्रेज़ी में). Robux में बार-बार ख़रीदारी और ProcessReceipt
- Roblox Creator Docs: StarterGear (अंग्रेज़ी में). StarterGear का Tool respawn के बाद क्यों लौटता है
- Roblox Creator Docs: In-game tools (अंग्रेज़ी में). Handle, Anchored और RequiresHandle
कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।