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

Roblox में सिम्युलेटर गेम कैसे बनाएं

लगभग सभी सिम्युलेटर एक ही लूप पर चलते हैं: कुछ आसान करो और करेंसी पाओ, उसे ऐसे अपग्रेड पर ख़र्च करो जो उसे और तेज़ी से लाएँ, फिर रीबर्थ करो ताकि स्थायी मल्टीप्लायर के साथ नए सिरे से शुरू कर सको। इस गाइड में हम यह लूप तीन स्क्रिप्ट वाले क्लिकर के रूप में बनाते हैं, जहाँ हर नंबर सर्वर तय करता है, और DataStore ट्यूटोरियल के PlayerData मॉड्यूल से प्रोग्रेस सेव करते हैं। अगर आपने Studio में अभी तक कोई गेम नहीं बनाया, तो पहले कॉइन वाला एक छोटा ट्रैक बनाएँ।

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

संक्षेप में

Roblox में सिम्युलेटर एक लूप है: कॉइन पाने के लिए क्लिक करो, उन्हें ऐसे अपग्रेड पर ख़र्च करो जो ज़्यादा दें, फिर स्थायी मल्टीप्लायर के लिए रीबर्थ करो। कीमतें ReplicatedStorage के एक ModuleScript में रखें। ServerScriptService की एक Script हर प्लेयर के Coins, Click Power और Rebirths रखती है, Click RemoteEvent से सेकंड में 15 से ज़्यादा क्लिक नहीं गिनती, और कीमत जाँचकर RemoteFunction से अपग्रेड और रीबर्थ बेचती है। एक LocalScript Click, Upgrade और Rebirth बटन दिखाती है। इस गाइड के नंबरों के साथ, सेकंड में 5 बार क्लिक करने वाला प्लेयर लगभग 1.2 मिनट में पहले रीबर्थ तक पहुँचता है, और रफ़्तार वाली तालिका दिखाती है कि चढ़ाई लंबी करने के लिए क्या बदलें।

  • क्लिक में क्लिक के सिवा कुछ नहीं जाता। उसकी कीमत सर्वर गिनता है, इसलिए बदला हुआ क्लाइंट ख़ुद को कॉइन नहीं दे सकता।
  • पूरी टेबल टाइमर पर और प्लेयर के जाने पर सेव करें, हर क्लिक पर नहीं। Roblox हर सर्वर को डेटा स्टोर में मिनट में 60 + 40 × प्लेयर लिखने की इजाज़त देता है।
  • स्क्रिप्टिंग नहीं आती? यही लूप Creator Store का किट, कोई प्लगइन या AI एजेंट बना सकता है। जाँच लें कि कॉइन सर्वर तय करता है: विकल्प।
  • बटन की जगह जिम या खदान चाहिए? एक Tool वही Click रिमोट कॉल कर सकता है: डम्बल वाला वर्ज़न। फिर नीचे दिए बनाने के क्रम से सिस्टम जोड़ें।
इस पेज पर
  1. यह कैसे काम करता है
  2. 1. सेटिंग मॉड्यूल
  3. 2. सर्वर स्क्रिप्ट
  4. 3. बटन
  5. 4. सेव
  6. सर्वर क्यों तय करता है
  7. 5. जाँच
  8. डम्बल वाला वर्ज़न
  9. बनाने का क्रम
  10. बिना स्क्रिप्टिंग
  11. कैसे बढ़ाएँ
  12. जॉनर
  13. Common errors
  14. RoCode के साथ
  15. अक्सर पूछे जाने वाले सवाल
  16. स्रोत और आगे पढ़ें

सिम्युलेटर का मुख्य लूप कैसे बना है

उदाहरणप्लेयर 10 कॉइन में Click Power लेवल 2 ख़रीदता है, फिर (तेज़ किया हुआ) 1,000 कॉइन जमा करके रीबर्थ करता है: कॉइन और अपग्रेड रीसेट हो जाते हैं, और हर क्लिक x2 का हो जाता है।

सिम्युलेटर तीन कामों का लूप है। प्लेयर करेंसी कमाने के लिए बार-बार कुछ आसान करता है, उसे ऐसे अपग्रेड पर ख़र्च करता है जो उसे तेज़ी से लाएँ, और जब अपग्रेड महँगे हो जाएँ तो रीबर्थ करता है: हमेशा रहने वाले बोनस के बदले कॉइन और अपग्रेड छोड़ देता है और फिर से चढ़ता है, इस बार तेज़ी से। दूसरे सिम्युलेटर में क्लिक की जगह डम्बल उठाते हैं, खुदाई करते हैं या चीज़ें जमा करते हैं, लेकिन नीचे लूप वही है।

इस गाइड के लूप के तीन काम
कामकीमतक्या देता हैकौन तय करता है
क्लिककुछ नहींकॉइन, Click Power × (Rebirths + 1) के बराबरसर्वर, जो हर एक सेकंड की विंडो में 15 से ज़्यादा क्लिक नहीं गिनता
अपग्रेड10 कॉइन, फिर हर लेवल पर पिछली कीमत का 1.5 गुनाClick Power का एक और लेवल, 50वें तकसर्वर, कीमतों की अपनी कॉपी से
रीबर्थ1,000 कॉइन, फिर हर रीबर्थ पर पिछली कीमत का 3 गुनाकॉइन वापस 0 और Click Power वापस लेवल 1, साथ में मल्टीप्लायर में स्थायी +1सर्वर

हर नंबर सर्वर पर रहता है। प्लेयर का डिवाइस बटन दिखाता है और अनुरोध करता है ("मैंने क्लिक किया", "मुझे अपग्रेड चाहिए"), और सर्वर तय करता है कि उसकी कीमत क्या है और वह हो सकता है या नहीं। जिन क्लिकर स्क्रिप्ट को तोड़ा जाता है, वे अक्सर LocalScript में कॉइन जोड़ती हैं या क्लाइंट को बताने देती हैं कि कितने कॉइन जोड़ने हैं।

सिम्युलेटर किन चीज़ों से बना है
हिस्साकहाँ हैक्या करता है
ModuleScript SimulatorConfigReplicatedStorageक्लिक की कीमत, अपग्रेड की कीमत और रीबर्थ की कीमत के लिए दाम, सीमाएँ और फ़ॉर्मूले। दोनों तरफ़ इसे पढ़ती हैं।
Script SimulatorServiceServerScriptServiceहर प्लेयर के नंबर रखती है, क्लिक, अपग्रेड और रीबर्थ संभालती है और leaderstats भरती है।
Folder SimulatorRemotesReplicatedStorage (इसे SimulatorService बनाती है)RemoteEvent Click और RemoteFunction BuyUpgrade और Rebirth।
LocalScript SimulatorClientStarterPlayerScriptsबटन बनाती है, क्लिक और अनुरोध भेजती है और सर्वर के नंबर दिखाती है।
ModuleScript PlayerData (वैकल्पिक)ServerScriptServiceआने-जाने के बीच प्रोग्रेस सेव करता है। यह DataStore ट्यूटोरियल से लिया गया है और सिर्फ़ स्टेप 4 के लिए चाहिए।
गेम के दौरान Explorer। SimulatorService गेम शुरू होने पर SimulatorRemotes और तीन रिमोट बनाती है, और PlayerData तभी दिखता है जब आप स्टेप 4 में सेव जोड़ते हैं।
ReplicatedStorage
  SimulatorConfig ModuleScript new
  SimulatorRemotes Folder new
    Click RemoteEvent new
    BuyUpgrade RemoteFunction new
    Rebirth RemoteFunction new
ServerScriptService
  SimulatorService Script new
  PlayerData ModuleScript
StarterPlayer
  StarterPlayerScripts
    SimulatorClient LocalScript new

स्टेप 1: कीमतें और फ़ॉर्मूले एक मॉड्यूल में रखें

हर वह नंबर जिसे आप शायद बदलना चाहें, एक ModuleScript में जाता है: क्लिक की कीमत, हर अपग्रेड और रीबर्थ की कीमत और क्लिक की सीमा। सर्वर इसी से फ़ैसला करता है, और LocalScript बटन के लिए कीमतें इसी से लेती है, इसलिए हर बदलाव एक ही जगह एक ही सुधार है।

  1. Explorer में ReplicatedStorage पर कर्सर ले जाएँ, + बटन दबाएँ और एक ModuleScript डालें।
  2. उसका नाम बदलकर SimulatorConfig रखें (नामों में बड़े-छोटे अक्षर मायने रखते हैं) और उसकी सामग्री नीचे के कोड से बदलें।
ModuleScript स्थान: ReplicatedStorage नाम: SimulatorConfig
-- मुख्य लूप के सभी नंबर और फ़ॉर्मूले जिन्हें दोनों तरफ़ इस्तेमाल करती हैं। क्लाइंट इनसे सिर्फ़
-- कीमतें दिखाता है; सर्वर अपनी ख़ुद की कॉपी से फ़ैसला करता है।

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- Click Power लेवल 2 की कीमत
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- हर लेवल पिछले से 1.5 गुना महँगा है
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- पहले रीबर्थ के कॉइन
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- हर रीबर्थ पिछले से 3 गुना महँगा है
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- एक सेकंड में इससे ज़्यादा क्लिक नज़रअंदाज़ होते हैं

-- एक क्लिक के कॉइन: Click Power लेवल गुणा 1 + रीबर्थ की संख्या
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Click Power के अगले लेवल की कीमत
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- अगले रीबर्थ के लिए ज़रूरी कॉइन
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

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

इन सेटिंग के साथ फ़ॉर्मूले क्या देते हैं
Click Power लेवलअगले लेवल की कीमतप्रति क्लिक कॉइन, बिना रीबर्थप्रति क्लिक कॉइन, 1 रीबर्थ
11012
21524
32236
43348
550510

रीबर्थ की कीमत 1,000 कॉइन है, फिर 3,000, फिर 9,000, क्योंकि rebirthCost हर बार कीमत को 3 से गुणा करता है। एक रीबर्थ के बाद हर क्लिक दोगुना होता है, दो के बाद तिगुना, और इसी तरह आगे।

इन नंबरों के साथ रीबर्थ में कितना समय लगता है

फ़ॉर्मूले तय करते हैं कि लूप कितना लंबा है, इसलिए प्लेयर से पहले नंबर गिन लेना अच्छा है। तालिका मानती है कि प्लेयर जैसे ही रीबर्थ का ख़र्च उठा सके, रीबर्थ करता है, और बाकी समय Click Power का अगला लेवल तब ख़रीदता है जब वह उसे ख़रीद सके और वह रीबर्थ से सस्ता हो। समय नई शुरुआत से गिना जाता है, इसलिए आख़िरी कॉलम 3 रीबर्थ तक का कुल समय है।

सेकंड में 5 क्लिक पर नई शुरुआत से हर रीबर्थ तक के मिनट, REBIRTH_BASE_COST के हिसाब से। SimulatorConfig के फ़ॉर्मूलों से गिना गया, प्लेयर पर मापा नहीं गया
REBIRTH_BASE_COSTरीबर्थ 1रीबर्थ 2रीबर्थ 3
1,000 (यह गाइड)1.22.74.8
5,0004.310.118.3
10,0008.216.933.2
25,00016.740.174.5
50,00032.868.8137.8

बिना रीबर्थ के Click Power लेवल 5, 34 क्लिक में आता है, लेवल 10, 122 में, और लेवल 13, 285 में। डिफ़ॉल्ट नंबरों के साथ प्लेयर इसके बाद लेवल बढ़ाना बंद कर देता है, क्योंकि लेवल 14 की कीमत 1,297 कॉइन है, जो 1,000 कॉइन के रीबर्थ से ज़्यादा है, और पहला रीबर्थ कुल 362 क्लिक में आता है। सर्वर की सेकंड में 15 क्लिक की सीमा पर हर समय को 3 से भाग दें। SimulatorConfig में कोई भी नंबर बदलें, तो ये समय भी साथ बदल जाएँगे, इसलिए उन्हें दोबारा गिनें।

ग्रोथ की सेटिंग

दो _GROWTH नंबर तय करते हैं कि कीमतें कितनी तेज़ी से बढ़ती हैं। 1.5 पर हर अपग्रेड पिछले से डेढ़ गुना महँगा है, जबकि हर लेवल प्रति क्लिक सिर्फ़ एक कॉइन जोड़ता है (रीबर्थ मल्टीप्लायर से पहले), इसलिए हर नया लेवल वसूल होने में ज़्यादा समय लेता है। यही धीमापन रीबर्थ को फ़ायदेमंद बनाता है। लंबी चढ़ाई के लिए ग्रोथ बढ़ाएँ, तेज़ के लिए घटाएँ, और REBIRTH_BASE_COST इतना ऊँचा रखें कि प्लेयर पहले रीबर्थ से पहले कुछ अपग्रेड ख़रीदें।

अगर पहला रीबर्थ लगभग एक मिनट की जगह कुछ मिनट में आना चाहिए, तो REBIRTH_BASE_COST को 5,000 या 10,000 तक बढ़ाएँ।

स्टेप 2: सर्वर स्क्रिप्ट जोड़ें

यह Script हर नंबर की मालिक है। यह रिमोट बनाती है, हर प्लेयर को Coins और Rebirths वाला leaderstats फ़ोल्डर देती है और तीन अनुरोधों का जवाब देती है। ServerScriptService पर कर्सर ले जाएँ, एक Script डालें, उसका नाम SimulatorService रखें और सामग्री इस कोड से बदलें:

Script स्थान: ServerScriptService नाम: SimulatorService
-- हर नंबर की मालिक: क्लिक यहाँ कॉइन लाते हैं, अपग्रेड और रीबर्थ यहाँ ख़रीदे जाते हैं,
-- और leaderstats सिर्फ़ नतीजा दिखाते हैं।

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- false: हर बार सब शून्य से शुरू करते हैं। true: PlayerData मॉड्यूल से लोड और सेव
-- DataStore ट्यूटोरियल से (पहले उसके DEFAULTS में PowerLevel = 1 और Rebirths = 0 जोड़ें)।
local SAVE_PROGRESS = false

type Config = {
	MAX_POWER_LEVEL: number,
	MAX_CLICKS_PER_SECOND: number,
	clickValue: (powerLevel: number, rebirths: number) -> number,
	upgradeCost: (powerLevel: number) -> number,
	rebirthCost: (rebirths: number) -> number,
}
local Config = require(ReplicatedStorage:WaitForChild("SimulatorConfig")) :: Config

type Stats = { Coins: number, PowerLevel: number, Rebirths: number }

local remotes = Instance.new("Folder")
remotes.Name = "SimulatorRemotes"
local clickEvent = Instance.new("RemoteEvent")
clickEvent.Name = "Click"
clickEvent.Parent = remotes
local buyUpgrade = Instance.new("RemoteFunction")
buyUpgrade.Name = "BuyUpgrade"
buyUpgrade.Parent = remotes
local rebirthRemote = Instance.new("RemoteFunction")
rebirthRemote.Name = "Rebirth"
rebirthRemote.Parent = remotes
remotes.Parent = ReplicatedStorage

local playerStats: { [Player]: Stats } = {}
local windowStart: { [Player]: number } = {} -- इस प्लेयर की मौजूदा एक सेकंड की विंडो कब शुरू हुई
local clickCount: { [Player]: number } = {} -- इस विंडो में गिने गए क्लिक

-- सर्वर के नंबर वहाँ कॉपी करता है जहाँ प्लेयर उन्हें देखते हैं: leaderstats और एक attribute में
local function refresh(player: Player)
	local data = playerStats[player]
	local leaderstats = player:FindFirstChild("leaderstats")
	if not (data and leaderstats) then
		return
	end
	local coins = leaderstats:FindFirstChild("Coins")
	local rebirths = leaderstats:FindFirstChild("Rebirths")
	if coins and coins:IsA("IntValue") then
		coins.Value = data.Coins
	end
	if rebirths and rebirths:IsA("IntValue") then
		rebirths.Value = data.Rebirths
	end
	player:SetAttribute("PowerLevel", data.PowerLevel)
end

-- दिए गए डेटा के साथ प्लेयर शुरू करता है (नए नंबर या सेव की गई टेबल)
local function setup(player: Player, data: Stats)
	playerStats[player] = data
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"
	for _, name in { "Coins", "Rebirths" } do
		local value = Instance.new("IntValue")
		value.Name = name
		value.Parent = leaderstats
	end
	leaderstats.Parent = player
	refresh(player)
end

-- क्लिक में कोई नंबर नहीं होता: उसकी कीमत सर्वर गिनता है
clickEvent.OnServerEvent:Connect(function(player: Player)
	local data = playerStats[player]
	if not data then
		return
	end
	local now = os.clock()
	local start = windowStart[player]
	if not start or now - start >= 1 then
		windowStart[player] = now
		clickCount[player] = 0
	end
	local count = clickCount[player] or 0
	if count >= Config.MAX_CLICKS_PER_SECOND then
		return -- ऑटो क्लिकर या स्क्रिप्ट जो लूप में रिमोट कॉल करती है
	end
	clickCount[player] = count + 1
	data.Coins += Config.clickValue(data.PowerLevel, data.Rebirths)
	refresh(player)
end)

buyUpgrade.OnServerInvoke = function(player: Player): (boolean, string)
	local data = playerStats[player]
	if not data then
		return false, "Your stats have not loaded yet."
	end
	if data.PowerLevel >= Config.MAX_POWER_LEVEL then
		return false, "Click Power is maxed out."
	end
	local cost = Config.upgradeCost(data.PowerLevel)
	if data.Coins < cost then
		return false, `You need {cost - data.Coins} more coins.`
	end
	data.Coins -= cost
	data.PowerLevel += 1
	refresh(player)
	return true, `Click Power is now level {data.PowerLevel}.`
end

rebirthRemote.OnServerInvoke = function(player: Player): (boolean, string)
	local data = playerStats[player]
	if not data then
		return false, "Your stats have not loaded yet."
	end
	local cost = Config.rebirthCost(data.Rebirths)
	if data.Coins < cost then
		return false, `You need {cost - data.Coins} more coins to rebirth.`
	end
	-- रीबर्थ कॉइन और अपग्रेड को स्थायी मल्टीप्लायर से बदलता है
	data.Coins = 0
	data.PowerLevel = 1
	data.Rebirths += 1
	refresh(player)
	return true, `Rebirth {data.Rebirths}! Every click is now worth x{data.Rebirths + 1}.`
end

-- शुरुआती नंबर: नए, या वह टेबल जिसे PlayerData मॉड्यूल लोड और सेव करता है
if SAVE_PROGRESS then
	type PlayerDataModule = {
		Loaded: RBXScriptSignal,
		Get: (player: Player) -> any,
	}
	local PlayerData = require(ServerScriptService:WaitForChild("PlayerData")) :: PlayerDataModule
	local function onLoaded(player: Player)
		local data = PlayerData.Get(player)
		if not data or playerStats[player] then
			return
		end
		if type(data.Coins) ~= "number" or type(data.PowerLevel) ~= "number" or type(data.Rebirths) ~= "number" then
			warn("SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module")
			return
		end
		setup(player, data) -- वही टेबल जिसे PlayerData सेव करता है, इसलिए हर बदलाव सेव होता है
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- वे सब जिनका डेटा इस स्क्रिप्ट के शुरू होने से पहले लोड हो गया
	end
else
	local function onPlayerAdded(player: Player)
		setup(player, { Coins = 0, PowerLevel = 1, Rebirths = 0 })
	end
	Players.PlayerAdded:Connect(onPlayerAdded)
	for _, player in Players:GetPlayers() do
		onPlayerAdded(player)
	end
end

Players.PlayerRemoving:Connect(function(player: Player)
	playerStats[player] = nil
	windowStart[player] = nil
	clickCount[player] = nil
end)

Click Power प्लेयर तक उसके Player ऑब्जेक्ट पर PowerLevel attribute के रूप में पहुँचता है, leaderstats के तीसरे मान के रूप में नहीं, इसलिए प्लेयर लिस्ट सिर्फ़ Coins और Rebirths दिखाती है। सर्वर के सेट किए attributes प्लेयर के डिवाइस तक replicate होते हैं; प्लेयर अपने डिवाइस पर जो बदलाव करे, वह वहीं रहता है।

क्लिक और रफ़्तार की सीमा

Click रिमोट कोई आर्ग्युमेंट नहीं भेजता। सर्वर पर OnServerEvent हैंडलर का पहला पैरामीटर हमेशा वह प्लेयर होता है जिसने उसे कॉल किया, इसलिए सर्वर जानता है कि किसने क्लिक किया, उसका Click Power लेवल और Rebirths लेता है और उसके Coins में clickValue जोड़ता है। अनुरोध में ऐसा कुछ नहीं जो चीटर बदल सके।

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

अपग्रेड और रीबर्थ

BuyUpgrade और Rebirth RemoteFunction हैं, इसलिए बटन जवाब का इंतज़ार करके उसे दिखा सकता है। हर हैंडलर SimulatorConfig की सर्वर कॉपी से कीमत लेता है, प्लेयर के Coins जाँचता है और उसके बाद ही कुछ बदलता है। वह true या false और एक संदेश लौटाता है, जैसे "You need 5 more coins.", जिसे LocalScript स्टेटस लाइन में दिखाती है।

कीमत की जाँच और बदलाव के बीच कुछ भी इंतज़ार या yield नहीं करता, इसलिए एक ही प्लेयर के दो अनुरोध पहले वाले के कॉइन लेने से पहले दोनों जाँच पार नहीं कर सकते। रीबर्थ Coins को 0, Click Power को लेवल 1 करता है और Rebirths में 1 जोड़ता है, और क्लिक का फ़ॉर्मूला इसे Rebirths + 1 के मल्टीप्लायर में बदल देता है।

SAVE_PROGRESS स्विच

SAVE_PROGRESS = false के साथ हर प्लेयर हर बार 0 कॉइन से शुरू करता है, और गेम बनाते समय यही चाहिए। स्टेप 4 इसे चालू करता है। तब स्क्रिप्ट इंतज़ार करती है कि PlayerData मॉड्यूल हर प्लेयर को लोड करे, और सीधे उसी टेबल के साथ काम करती है जिसे यह मॉड्यूल सेव करता है, इसलिए हर कॉइन और हर रीबर्थ बिना अतिरिक्त कोड के सेव होता है।

स्टेप 3: बटन बनाएँ

यह LocalScript पूरी स्क्रीन कोड में बनाती है: ऊपर कॉइन काउंटर, बीच में बड़ा Click बटन, नीचे Upgrade और Rebirth बटन और सर्वर के जवाबों के लिए एक स्टेटस लाइन। यह ख़ुद कभी कोई नंबर नहीं बदलती।

  1. Explorer में StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ और SimulatorClient नाम की एक LocalScript डालें।
  2. उसकी सामग्री नीचे के कोड से बदलें और Play दबाएँ।
LocalScript स्थान: StarterPlayerScripts नाम: SimulatorClient
-- सिम्युलेटर के बटन बनाती है और सर्वर के नंबर दिखाती है। ख़ुद उन्हें कभी नहीं बदलती।

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TweenService = game:GetService("TweenService")

type Config = {
	MAX_POWER_LEVEL: number,
	clickValue: (powerLevel: number, rebirths: number) -> number,
	upgradeCost: (powerLevel: number) -> number,
	rebirthCost: (rebirths: number) -> number,
}
local Config = require(ReplicatedStorage:WaitForChild("SimulatorConfig")) :: Config
local remotes = ReplicatedStorage:WaitForChild("SimulatorRemotes")
local clickEvent = remotes:WaitForChild("Click") :: RemoteEvent
local buyUpgrade = remotes:WaitForChild("BuyUpgrade") :: RemoteFunction
local rebirthRemote = remotes:WaitForChild("Rebirth") :: RemoteFunction

local player = Players.LocalPlayer
local leaderstats = player:WaitForChild("leaderstats")
local coins = leaderstats:WaitForChild("Coins") :: IntValue
local rebirths = leaderstats:WaitForChild("Rebirths") :: IntValue

local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)

-- 1234 -> "1.2K", 5600000 -> "5.6M"
local UNITS = {
	{ size = 1e12, suffix = "T" },
	{ size = 1e9, suffix = "B" },
	{ size = 1e6, suffix = "M" },
	{ size = 1e3, suffix = "K" },
}
local function short(n: number): string
	for _, unit in UNITS do
		if n >= unit.size then
			return string.format("%.1f%s", math.floor(n / unit.size * 10) / 10, unit.suffix)
		end
	end
	return tostring(n)
end

local function newButton(parent: Instance, text: string, position: UDim2, size: UDim2, color: Color3): TextButton
	local button = Instance.new("TextButton")
	button.AnchorPoint = Vector2.new(0.5, 0.5)
	button.Position = position
	button.Size = size
	button.BackgroundColor3 = color
	button.TextColor3 = Color3.new(1, 1, 1)
	button.FontFace = BOLD
	button.TextScaled = true
	button.Text = text
	button.Parent = parent
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, 12)
	corner.Parent = button
	return button
end

local gui = Instance.new("ScreenGui")
gui.Name = "SimulatorGui"
gui.ResetOnSpawn = false

local coinsLabel = Instance.new("TextLabel")
coinsLabel.AnchorPoint = Vector2.new(0.5, 0)
coinsLabel.Position = UDim2.new(0.5, 0, 0, 12)
coinsLabel.Size = UDim2.fromOffset(320, 48)
coinsLabel.BackgroundTransparency = 1
coinsLabel.TextColor3 = Color3.fromRGB(255, 214, 90)
coinsLabel.FontFace = BOLD
coinsLabel.TextScaled = true
coinsLabel.Parent = gui

local clickButton = newButton(gui, "Click!", UDim2.new(0.5, 0, 0.5, -30), UDim2.fromScale(0.38, 0.38), Color3.fromRGB(124, 77, 255))
-- Click बटन चौकोर रहता है, स्क्रीन के साइज़ के हिसाब से और 200 गुणा 200 से बड़ा नहीं,
-- ताकि फ़ोन पर वह कॉइन काउंटर और नीचे के बटनों के बीच आ जाए
local square = Instance.new("UIAspectRatioConstraint")
square.Parent = clickButton
local maxSize = Instance.new("UISizeConstraint")
maxSize.MaxSize = Vector2.new(200, 200)
maxSize.Parent = clickButton

local upgradeButton = newButton(gui, "", UDim2.new(0.5, -110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(40, 150, 90))
local rebirthButton = newButton(gui, "", UDim2.new(0.5, 110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(200, 90, 40))

local status = Instance.new("TextLabel")
status.AnchorPoint = Vector2.new(0.5, 1)
status.Position = UDim2.new(0.5, 0, 1, -96)
status.Size = UDim2.fromOffset(480, 28)
status.BackgroundTransparency = 1
status.TextColor3 = Color3.new(1, 1, 1)
status.FontFace = BOLD
status.TextSize = 20
status.Text = ""
status.Parent = gui

gui.Parent = player:WaitForChild("PlayerGui")

local function powerLevel(): number
	local level = player:GetAttribute("PowerLevel")
	return if type(level) == "number" then level else 1
end

local function update()
	coinsLabel.Text = `{short(coins.Value)} coins`
	local level = powerLevel()
	upgradeButton.Text = if level >= Config.MAX_POWER_LEVEL
		then "Click Power maxed"
		else `Upgrade: {short(Config.upgradeCost(level))}`
	rebirthButton.Text = `Rebirth: {short(Config.rebirthCost(rebirths.Value))}`
end
coins.Changed:Connect(update)
rebirths.Changed:Connect(update)
player:GetAttributeChangedSignal("PowerLevel"):Connect(update)
update()

-- "+N" जो बटन के ऊपर उभरता है। नंबर सिर्फ़ दिखाने के लिए अंदाज़ा है;
-- क्लिक की असली कीमत सर्वर तय करता है।
local function popUp()
	local pop = Instance.new("TextLabel")
	pop.AnchorPoint = Vector2.new(0.5, 0.5)
	pop.Position = UDim2.fromScale(0.5 + (math.random() - 0.5) * 0.1, 0.42)
	pop.Size = UDim2.fromOffset(120, 40)
	pop.BackgroundTransparency = 1
	pop.TextColor3 = Color3.fromRGB(255, 214, 90)
	pop.FontFace = BOLD
	pop.TextScaled = true
	pop.Text = `+{short(Config.clickValue(powerLevel(), rebirths.Value))}`
	pop.Parent = gui
	local tween = TweenService:Create(pop, TweenInfo.new(0.6), {
		Position = pop.Position - UDim2.fromOffset(0, 60),
		TextTransparency = 1,
	})
	tween.Completed:Once(function()
		pop:Destroy()
	end)
	tween:Play()
end

clickButton.Activated:Connect(function()
	clickEvent:FireServer()
	popUp()
end)

local function ask(remote: RemoteFunction)
	local ok, success, message = pcall(function()
		return remote:InvokeServer()
	end)
	status.Text = if ok and type(message) == "string" then message else "No answer from the server. Try again."
	status.TextColor3 = if ok and success == true then Color3.fromRGB(120, 220, 150) else Color3.new(1, 1, 1)
end

upgradeButton.Activated:Connect(function()
	ask(buyUpgrade)
end)
rebirthButton.Activated:Connect(function()
	ask(rebirthRemote)
end)

बटन Activated इस्तेमाल करते हैं, जिसे Roblox कंप्यूटर पर माउस के बाएँ क्लिक पर, फ़ोन पर टच पर और UI नेविगेशन मोड में गेमपैड पर A (या क्रॉस) दबाने पर चलाता है।

गेमपैड पर A सिर्फ़ चुना हुआ बटन दबाता है। जब GuiService.AutoSelectGuiEnabled चालू है, तो गेमपैड का Select बटन आपके स्क्रीन बटन चुनता है; इसके बाद प्लेयर उनके बीच जा सकते हैं और A दबा सकते हैं। अगर आप चाहते हैं कि गेमपैड का कोई बटन सीधे क्लिक करे, तो उसे ContextActionService से बाँधें और उससे वही Click रिमोट कॉल करें।

स्क्रिप्ट की चार बातें:

  • Click बटन स्क्रीन के हिसाब से बदलता है। उसका साइज़ स्क्रीन का एक हिस्सा है, UIAspectRatioConstraint उसे चौकोर रखता है, और UISizeConstraint उसे 200 गुणा 200 पिक्सेल तक सीमित करता है। मॉनिटर पर वह 200 पिक्सेल चौड़ा है; फ़ोन पर वह छोटा होकर कॉइन काउंटर और नीचे के बटनों के बीच आ जाता है। अगर आप चीज़ें खिसकाते हैं, तो उसे उनसे दूर रखें: Rebirth की कोई पुष्टि नहीं होती, इसलिए गलती से छूने पर प्लेयर के कॉइन और अपग्रेड रीसेट हो सकते हैं।
  • उभरने वाला "+N" सिर्फ़ दिखाने के लिए है। वह फ़ॉर्मूले की क्लाइंट कॉपी लेता है। अगर सर्वर रफ़्तार सीमा के कारण क्लिक नज़रअंदाज़ करे, तो "+N" फिर भी दिखेगा, लेकिन कॉइन नहीं बदलेंगे।
  • short() बड़े नंबरों को पढ़ने लायक बनाता है। 1,234 को 1.2K और 5,600,000 को 5.6M दिखाता है। फ़ंक्शन नीचे की ओर राउंड करता है, इसलिए काउंटर कभी आपके पास जितना है उससे ज़्यादा नहीं दिखाता। T (ट्रिलियन) से बड़े नंबरों के लिए UNITS में एंट्री जोड़ें।
  • स्क्रीन इवेंट के हिसाब से अपडेट होती है। वह Coins और Rebirths मान और PowerLevel attribute सुनती है, इसलिए नंबर कैसे भी बदलें, बटन पर कीमतें सही रहती हैं।

ScreenGui का ResetOnSpawn false पर है, इसलिए कैरेक्टर के respawn होने पर वह बना रहता है। यहाँ यह ज़रूरी है: StarterPlayerScripts की LocalScript प्लेयर को एक बार, जॉइन करते समय कॉपी होती है, इसलिए वह स्क्रीन दोबारा नहीं बनाती।

स्टेप 4: PlayerData से प्रोग्रेस सेव करें

अभी प्लेयर के जाने पर सब कुछ रीसेट हो जाता है। दूसरी सेव स्क्रिप्ट की जगह सिम्युलेटर DataStore ट्यूटोरियल के PlayerData मॉड्यूल से जुड़ता है। यह मॉड्यूल पहले से असफल अनुरोध दोहराता है, हर 180 सेकंड में ऑटोसेव करता है, प्लेयर के जाने और सर्वर बंद होने पर सेव करता है, और उस प्लेयर को कभी सेव नहीं करता जिसका डेटा लोड नहीं हुआ।

  1. ServerScriptService में PlayerData ModuleScript जोड़ने के लिए DataStore ट्यूटोरियल का स्टेप 1 पूरा करें। Studio में सेव जाँचने के लिए गेम की टेस्ट कॉपी में Studio का API सर्विस एक्सेस चालू करें, जैसा उसका पहला सेक्शन समझाता है। SimulatorService ख़ुद require से मॉड्यूल जोड़ती है, इसलिए ट्यूटोरियल की Main स्क्रिप्ट की यहाँ ज़रूरत नहीं।
  2. PlayerData में DEFAULTS टेबल में Coins = 0, के बगल में PowerLevel = 1, और Rebirths = 0, जोड़ें।
  3. उसी मॉड्यूल में Data टाइप में PowerLevel: number, और Rebirths: number, जोड़ें, ताकि strict type checking नए फ़ील्ड के बारे में जाने।
  4. SimulatorService में local SAVE_PROGRESS = false को local SAVE_PROGRESS = true से बदलें।

जो प्लेयर फ़ील्ड जोड़ने से पहले सेव हुए थे, उन्हें वे अपने आप मिल जाते हैं: PlayerData का migrate फ़ंक्शन DEFAULTS के वे सभी फ़ील्ड भरता है जो सेव टेबल में नहीं हैं, इसलिए वे Click Power लेवल 1 और 0 रीबर्थ से शुरू करते हैं और अपने Coins रखते हैं। अगर आप पॉइंट 2 छोड़ दें, तो SimulatorService उन फ़ील्ड की चेतावनी दिखाएगी जिन्हें जोड़ना है, और प्लेयर को शुरू नहीं करेगी।

सिम्युलेटर PlayerData की टेबल में क्यों लिखता है

जब सेव चालू है, SimulatorService नंबर कहीं कॉपी नहीं करती। PlayerData.Get(player) वह लाइव टेबल लौटाता है जिसे मॉड्यूल सेव करता है, और सिम्युलेटर इसी टेबल में Coins, PowerLevel और Rebirths बदलता है। हर नंबर की एक ही कॉपी है, और डेटा स्टोर में एक ही स्क्रिप्ट लिखती है। एक ही key सेव करने वाली दो स्क्रिप्ट एक-दूसरे को ओवरराइट करती हैं, और उनमें से एक दूसरी के नंबरों के ऊपर पुराने नंबर सेव कर सकती है।

Loaded हैंडलर में अलग से leaderstats न बनाएँ, जैसा DataStore ट्यूटोरियल दूसरे गेम के लिए सुझाता है: SimulatorService पहले से लोड की गई टेबल से Coins और Rebirths बनाती है। अगर leaderstats पहले से कोई लीडरबोर्ड स्क्रिप्ट बनाती है, तो उसे हटा दें।

हर क्लिक पर सेव क्यों नहीं

Roblox हर सर्वर को सामान्य डेटा स्टोर में मिनट में 60 + 40 × प्लेयर लिखने की इजाज़त देता है (बाकी DataStore ट्यूटोरियल की सीमाओं वाली तालिका में है)। सेकंड में 15 क्लिक पर हर क्लिक पर सेव करने का मतलब एक प्लेयर के लिए मिनट में 900 लिखना है, जो एक प्लेयर वाले सर्वर को मिलने वाले 100 से बहुत ज़्यादा है। हर 180 सेकंड में, प्लेयर के जाने पर और सर्वर बंद होने पर पूरी टेबल सेव करने में प्रति प्लेयर बस कुछ लिखना लगता है, और क्रैश होने पर ज़्यादा से ज़्यादा आख़िरी ऑटोसेव के बाद की प्रोग्रेस जाती है।

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

हर नंबर सर्वर क्यों तय करता है

Exploiter अपने डिवाइस को नियंत्रित करते हैं। Roblox की सुरक्षा गाइड कहती है कि वे गेम की अपनी लोकल कॉपी में कुछ भी बदल सकते हैं और कोई भी RemoteEvent या RemoteFunction जितनी बार चाहें, किसी भी आर्ग्युमेंट के साथ कॉल कर सकते हैं। सिम्युलेटर की इकॉनमी ठीक उतनी ही सुरक्षित है जितनी उसकी सर्वर स्क्रिप्ट।

Exploiter क्या आज़मा सकता है और SimulatorService क्या करती है
Exploiter कोशिश करता हैअगर क्लाइंट तय करताSimulatorService क्या करती है
लूप में जितना तेज़ हो सके Click कॉल करनाअनगिनत कॉइनहर एक सेकंड की विंडो में 15 से ज़्यादा क्लिक नहीं गिनती और बाकी नज़रअंदाज़ करती है।
क्लिक के साथ कॉइन की संख्या भेजनावह अपना इनाम ख़ुद चुनता हैहर आर्ग्युमेंट नज़रअंदाज़ करती है। क्लिक की कीमत सर्वर के नंबरों से आती है।
ज़रूरी कॉइन के बिना अपग्रेड या रीबर्थ ख़रीदनामुफ़्त अपग्रेडसर्वर पर कीमत को Coins से मिलाती है और जवाब देती है "You need N more coins."
अपनी स्क्रीन पर leaderstats में Coins बदलनाऐसे कॉइन ख़र्च करना जो उसके पास नहींleaderstats कभी नहीं पढ़ती। वह सिर्फ़ अपनी टेबल से वहाँ लिखती है।
अपने Player पर PowerLevel attribute सेट करनाज़्यादा ताक़तवर क्लिकयह attribute कभी नहीं पढ़ती, और बदलाव प्लेयर के डिवाइस पर ही रहता है।
एक ही पल में Rebirth दो बार कॉल करनाएक की कीमत में दो रीबर्थहर कॉल पर कीमत फिर से जाँचती है, और जाँच और बदलाव के बीच कुछ भी yield नहीं करता।
SimulatorConfig की अपनी कॉपी में कीमतें बदलनासस्ते अपग्रेडमॉड्यूल की अपनी कॉपी इस्तेमाल करती है।

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

कॉपी की हुई क्लिकर स्क्रिप्ट में किन चीज़ों से बचें

पुराने क्लिकर ट्यूटोरियल की आम तरकीबें और उनकी जगह यह गाइड क्या करती है
तरकीबसमस्यायह गाइड
LocalScript leaderstats.Coins.Value += 1 से कॉइन जोड़ती हैबदलाव एक ही डिवाइस पर रहता है, और अपने डिवाइस को exploiter नियंत्रित करता हैकॉइन सर्वर जोड़ता है
clickEvent:FireServer(amount)क्लाइंट अपना इनाम ख़ुद चुनता हैClick कोई आर्ग्युमेंट नहीं भेजता
सर्वर पर रफ़्तार सीमा नहींRoblox डॉक्यूमेंटेशन कहता है कि कभी सिर्फ़ क्लाइंट की सीमा पर भरोसा न करेंहर एक सेकंड की विंडो में 15 से ज़्यादा क्लिक नहीं
हर क्लिक या अपग्रेड पर SetAsyncसर्वर की लिखने की सीमा खा जाता हैPlayerData हर 180 सेकंड में, जाने पर और बंद होने पर सेव करता है। PlayerData.SaveNow से तुरंत सेव सिर्फ़ उस चीज़ के बाद करें जो खोनी नहीं चाहिए, जैसे Robux से ख़रीदारी।
सिर्फ़ सिम्युलेटर के लिए दूसरी डेटा स्टोर स्क्रिप्टएक ही key सेव करने वाली दो स्क्रिप्ट एक-दूसरे को ओवरराइट करती हैंPlayerData की टेबल में लिखती है
पैसिव इनकम के लिए while wait(1) do लूपRoblox ग्लोबल wait को पुराना (deprecated) बताता है, उसकी जगह task.wait हैtask.wait (देखें कैसे बढ़ाएँ)
बटन पर MouseButton1Clickमाउस क्लिक के लिए बताया गया हैActivated, माउस, टच और गेमपैड के लिए

स्टेप 5: जाँचें

SimulatorService में SAVE_PROGRESS = false के साथ पॉइंट 1 से 8 तक करें, ताकि हर playtest नए नंबरों से शुरू हो। अगर आपने स्टेप 4 में सेव पहले ही चालू कर दिया है, तो अभी false रखें, और पॉइंट 9 के लिए true वापस करें।

  1. Play दबाएँ। स्क्रीन के ऊपर 0 coins लिखा है, हरे बटन पर Upgrade: 10 और नारंगी पर Rebirth: 1.0K।
  2. बैंगनी Click! बटन दस बार दबाएँ। हर क्लिक सुनहरा +1 दिखाता है, और प्लेयर लिस्ट में Coins 1 बढ़ता है।
  3. Upgrade दबाएँ। कॉइन 0 पर लौटते हैं, स्टेटस लाइन "Click Power is now level 2." के साथ हरी हो जाती है, और बटन पर अब Upgrade: 15 है। अब से हर क्लिक 2 कॉइन देता है।
  4. बिना क्लिक किए Rebirth दबाएँ। स्टेटस लाइन में "You need 1000 more coins to rebirth." लिखा आता है, और कुछ नहीं बदलता।
  5. 1,000 क्लिक के बिना रीबर्थ जाँचने के लिए टेस्ट रोकें, SimulatorService के आख़िर के पास की उस लाइन में जो नए प्लेयर शुरू करती है, Coins = 0 को Coins = 1000 से बदलें, और Play दबाएँ। Rebirth दबाएँ: Coins 0 हो जाते हैं, प्लेयर लिस्ट में Rebirths 1 हो जाता है, स्टेटस लाइन में "Rebirth 1! Every click is now worth x2." आता है, और बटन पर अब Rebirth: 3.0K है। अब Click Power लेवल 1 पर हर क्लिक 2 कॉइन देता है। फिर लाइन को 0 पर वापस करें।
  6. रफ़्तार सीमा देखने के लिए SimulatorConfig में MAX_CLICKS_PER_SECOND को 2 करें और तेज़ी से क्लिक करें। "+N" दिखते रहते हैं, लेकिन Coins सेकंड में ज़्यादा से ज़्यादा 2 क्लिक की कीमत जितने बढ़ते हैं। 15 वापस करें।
  7. Studio के Device Simulator में एक फ़ोन चुनें (यह Studio बीटा है; पुराना Device Emulator भी चलेगा) और Play दबाएँ। जाँचें कि Click बटन न कॉइन काउंटर पर चढ़ता है, न Upgrade और Rebirth बटन पर, और कि Upgrade दबाने पर स्टेटस लाइन दिखती है और बटन से ढकती नहीं।
  8. Playtest के दौरान गेमपैड जोड़ें या Studio में Controller Emulator खोलें (Emulation टैब पर Controller), Select दबाएँ और जाँचें कि तीनों बटन तक पहुँचकर उन्हें A से दबाया जा सकता है।
  9. सेव चालू (स्टेप 4) और फिर से SAVE_PROGRESS = true के साथ कुछ कॉइन कमाएँ, Stop दबाएँ, फिर दोबारा Play। आपके Coins, Click Power लेवल और Rebirths वापस आ जाएँगे।

जिम या खदान वाला सिम्युलेटर बनाएँ

कई सिम्युलेटर बटन की जगह दुनिया में कोई काम रखते हैं: डम्बल उठाना, गैंती चलाना, हवा में तलवार घुमाना। नीचे वही क्लिक है। एक Tool वही Click रिमोट कॉल कर सकता है, इसलिए SimulatorService, उसकी कीमतें और उसकी रफ़्तार सीमा जैसी हैं वैसी रहती हैं।

  1. Explorer में StarterPack पर कर्सर ले जाएँ, एक Tool डालें और उसका नाम Dumbbell रखें। उसमें Handle नाम का एक Part डालें, उसे डम्बल का आकार दें और Anchored से टिक हटाएँ, जैसा तलवार गाइड के Tool वाले स्टेप में है।
  2. Tool में LiftClient नाम की एक LocalScript डालें और नीचे का कोड पेस्ट करें।
  3. Play दबाएँ, डम्बल लें और क्लिक करें। हर बार उठाने पर कॉइन आपके Click Power जितने बढ़ते हैं, बिल्कुल बटन की तरह।
LocalScript स्थान: StarterPack में Dumbbell Tool नाम: LiftClient
-- Dumbbell Tool के अंदर LocalScript, नाम LiftClient।
-- हर बार उठाना एक क्लिक है: यह वही Click रिमोट कॉल करता है जो बटन करता है, और सर्वर
-- तय करता है कि उसकी कीमत क्या है और कितनी बार उठाना गिनना है।

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local tool = script.Parent :: Tool
local remotes = ReplicatedStorage:WaitForChild("SimulatorRemotes")
local clickEvent = remotes:WaitForChild("Click") :: RemoteEvent

local LIFT_SECONDS = 0.5 -- इस डिवाइस पर दो बार उठाने के बीच का समय; सर्वर की अपनी सीमा है
local LIFT_ANIMATION_ID = "" -- वैकल्पिक: "rbxassetid://" और उसके बाद आपके ऐनिमेशन की id

local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil

-- हर कैरेक्टर पर उठाने का ऐनिमेशन एक बार लोड करते हैं, Animator से जो Roblox Humanoid में रखता है
local function loadLift()
	local character = player.Character
	if LIFT_ANIMATION_ID == "" or not character or character == trackCharacter then
		return
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	local animator = humanoid and humanoid:FindFirstChildOfClass("Animator")
	if animator then
		local animation = Instance.new("Animation")
		animation.AnimationId = LIFT_ANIMATION_ID
		liftTrack = animator:LoadAnimation(animation)
		trackCharacter = character
	end
end

tool.Equipped:Connect(loadLift)

tool.Activated:Connect(function()
	local now = os.clock()
	if now - lastLift < LIFT_SECONDS then
		return
	end
	lastLift = now
	if liftTrack then
		liftTrack:Play()
	end
	clickEvent:FireServer() -- बिना आर्ग्युमेंट: इनाम सर्वर गिनता है
end)

उठाने के ऐनिमेशन के लिए उसे Animation Editor में Action प्राथमिकता के साथ बनाएँ, पब्लिश करें और उसकी ID LIFT_ANIMATION_ID में डालें। तलवार गाइड के ऐनिमेशन वाले स्टेप भी ऐसे ही काम करते हैं।

  • सर्वर सीमा को काम के हिसाब से रखें। LIFT_SECONDS सिर्फ़ ईमानदार प्लेयर को धीमा करता है: चीटर अपने कोड से Click कॉल कर सकता है। अगर उठाना ही कमाने का एकमात्र तरीका है, तो SimulatorConfig में MAX_CLICKS_PER_SECOND को असली रफ़्तार तक घटाएँ, जैसे हर 0.5 सेकंड में एक बार उठाने के लिए 2, ताकि स्क्रिप्ट प्लेयर से ज़्यादा न कमा सके। फिर रफ़्तार वाली तालिका दोबारा गिनें: उसका हर समय सेकंड में 5 क्लिक पर आधारित है।
  • बटन रखें या छिपाएँ। Click बटन Tool के साथ काम करता रहता है। उसे छिपाने के लिए SimulatorClient में clickButton बनाने वाली लाइन के ठीक बाद clickButton.Visible = false जोड़ें।
  • सिर्फ़ सही जगह पर कमाई। सिर्फ़ जिम या खदान में भुगतान करने के लिए, क्लिक गिनने से पहले सर्वर पर जाँचें कि कैरेक्टर कहाँ है, जैसे उस ज़ोन के किसी पार्ट से दूरी से। LiftClient में जाँच किसी को नहीं रोकेगी।

आगे क्या करें: सिम्युलेटर बनाने का क्रम

सिम्युलेटर इस लूप के ऊपर सिस्टम का ढेर है। उन्हें इस क्रम में बनाएँ, ताकि हर एक के पास गुणा करने को कुछ हो, और हर एक के बाद playtest करें। यह वह क्रम है जो हम सुझाते हैं, हर स्टेप के लिए गाइड के साथ।

Roblox में सिम्युलेटर बनाने का क्रम, मुख्य लूप से बाहर की ओर
क्रमसिस्टमगाइडअभी क्यों
1कमाई, अपग्रेड, रीबर्थयह गाइडबाकी सब इसी लूप को गुणा करता है, इसलिए पहले रफ़्तार वाली तालिका से इसके नंबर सेट करें।
2सेवDataStore ट्यूटोरियल, फिर स्टेप 4दोबारा आने पर रीसेट होने वाली प्रोग्रेस सिम्युलेटर को मार देती है। इसे हर उस चीज़ से पहले जोड़ें जो प्लेयर खो सकते हैं।
3मल्टीप्लायर के रूप में अंडे और पेटअंडे खोलना और प्लेयर के पीछे चलने वाले पेटकॉइन के साथ दूसरा लक्ष्य: कुछ जमा करने लायक, जो हर क्लिक को और कीमती बनाए।
4रीबर्थ के पीछे ज़ोनकैसे बढ़ाएँरीबर्थ के बाद कहाँ जाएँ, बेहतर इनाम के साथ जिन्हें सर्वर जाँचता है।
5लीडरबोर्डलीडरबोर्ड गाइडरीबर्थ का ग्लोबल टॉप 10 लंबी चढ़ाई को मतलब देता है।
6डेली रिवॉर्ड और कोडडेली रिवॉर्ड और कोडकल और हर अपडेट के बाद लौटने की वजहें।
7गेमपासगेमपास गाइड2x कॉइन, ऑटो क्लिक या पेट के लिए अतिरिक्त स्लॉट, सर्वर जाँच के साथ। इन्हें तब बेचें जब मुफ़्त लूप पहले से मज़ेदार हो।

स्क्रीन के लिए मुफ़्त Roblox UI किट में सिम्युलेटर स्टाइल की स्क्रीन हैं, उन्हें चलाने वाली स्क्रिप्ट के साथ।

स्क्रिप्ट लिखे बिना सिम्युलेटर कैसे बनाएं

सिम्युलेटर को फिर भी स्क्रिप्ट चाहिए: किसी को कॉइन जोड़ने, कीमतें जाँचने और सेव करने हैं। उन्हें ख़ुद लिखना ज़रूरी नहीं:

  • Creator Store से सिम्युलेटर किट। पब्लिश करने से पहले उसकी स्क्रिप्ट पढ़ें और जाँचें कि कॉइन सिर्फ़ सर्वर Script में बदलते हैं, LocalScript में नहीं।
  • सिम्युलेटर बनाने वाला प्लगइन। वह जो भी बनाए, उस पर यही जाँच।
  • Studio में AI एजेंट, जैसे RoCode, जो यही तीन स्क्रिप्ट आपके खुले place में बना सकता है।
  • Roblox मोबाइल ऐप में Build। Roblox डॉक्यूमेंटेशन के अनुसार, यह विवरण से आसान 2D और 2.5D गेम बनाता है, जैसे क्लिकर, और धीरे-धीरे क्षेत्रों में आ रहा है।

जो भी चुनें, नतीजे पर स्टेप 5 की जाँच और हर नंबर सर्वर क्यों तय करता है सेक्शन की exploit जाँच चलाएँ।

कैसे बढ़ाएँ: पेट, ज़ोन, ऑटो क्लिक और लीडरबोर्ड

मल्टीप्लायर के रूप में पेट

आम तरीका: हर पेट एक मल्टीप्लायर है। प्लेयर के पेट की id की लिस्ट उसकी सेव टेबल में रखें, और सर्वर clickValue को हर पहने हुए पेट के बोनस से गुणा करे। अंडे सर्वर पर खोलें: क्लाइंट अंडा खोलने को कहता है, सर्वर जाँचकर कीमत लेता है, फिर weighted रैंडम से पेट चुनता है। क्लाइंट को कभी अंडे का रोल करने या यह बताने न दें कि कौन सा पेट निकला। इन्वेंटरी गाइड दिखाती है कि प्लेयर की चीज़ें कैसे रखें, सेव करें और दिखाएँ, और पेट भी ऐसे ही काम करते हैं। अंडे खोलने की गाइड सर्वर पर रोल बनाती है, और पेट गाइड पेट को मालिक के पास उड़ाती है।

रीबर्थ से खुलने वाले ज़ोन

ज़ोन मैप का एक हिस्सा है जिसमें बैरियर के पीछे बेहतर इनाम हैं। सिर्फ़ दरवाज़ा नहीं, इनाम बंद करें: ज़ोन के अंदर जो कुछ भी भुगतान करता है, उसे भुगतान से पहले सर्वर की टेबल में प्लेयर के Rebirths जाँचने चाहिए। जो दरवाज़ा LocalScript योग्य प्लेयर के लिए खोलती है, वह दिखाने के लिए ठीक है, लेकिन exploiter अपने डिवाइस पर पार्ट बदल सकते हैं और अपना कैरेक्टर हिला सकते हैं।

गेमपास के रूप में ऑटो क्लिक

गेमपास के रूप में बिकने वाला ऑटो क्लिकर सर्वर पर चलना चाहिए। Click हैंडलर का अंदरूनी हिस्सा एक फ़ंक्शन में ले जाएँ, जैसे addClick(player), रिमोट को उससे जोड़ें, और पास वालों के लिए उसे सर्वर लूप से task.wait(0.5) के साथ कॉल करें, पुराने wait के साथ नहीं। तब ऑटो क्लिक भी उसी प्रति सेकंड सीमा में गिने जाते हैं जिसमें सामान्य क्लिक। मालिकाना हक़ सर्वर पर MarketplaceService:UserOwnsGamePassAsync से जाँचें, जैसे गेमपास गाइड अपने बोनस के लिए करती है। 2x कॉइन पास भी ऐसे ही काम करता है: मालिकों के लिए सर्वर पर clickValue को गुणा करें। कीमत तय करने से पहले मुफ़्त Robux टैक्स कैलकुलेटर दिखाएगा कि Roblox के हिस्से के बाद हर बिक्री से आपको कितना मिलता है, और DevEx कैलकुलेटर दिखाएगा कि वे Robux अमेरिकी डॉलर में कितने के हैं।

रीबर्थ का ग्लोबल टॉप 10

leaderstats सिर्फ़ एक सर्वर के प्लेयर की तुलना करता है। सभी प्लेयर के Rebirths की रैंकिंग के लिए उन्हें ordered data store में लिखें और ऊपर की एंट्री वापस पढ़ें, जैसा लीडरबोर्ड गाइड के स्टेप 4 में है। Ordered स्टोर सामान्य से कम लिखने देते हैं, प्रति सर्वर मिनट में 30 + 5 × प्लेयर, इसलिए प्लेयर के जाने पर और टाइमर पर लिखें।

बहुत बड़े नंबर

Luau में नंबर double होते हैं, जो लगभग 15 सार्थक अंक रखते हैं। IntValue लगभग 9.2 क्विंटिलियन तक पूर्णांक रखता है, लेकिन Roblox चेतावनी देता है कि 2^53 (लगभग 9 क्वाड्रिलियन) से बड़े मान स्क्रिप्ट में सटीकता खोते हैं। इन सेटिंग के साथ रीबर्थ की कीमत 29वें रीबर्थ पर यह सीमा पार करती है। अगर आपका गेम इससे आगे जाता है, तो leaderstats के मान NumberValue पर ले जाएँ (दोनों स्क्रिप्ट में IntValue बदलें), जो लगभग 15 अंकों की उसी सटीकता के साथ बहुत बड़े नंबर रखता है, और short() में suffix जोड़ें।

सिम्युलेटर गेम किस पर टिका है

सिम्युलेटर नंबरों का गेम है। ऊपर का क्लिक, अपग्रेड और रीबर्थ पूरा लूप है; प्लेयर रुकेंगे या नहीं, यह इस पर निर्भर है कि ये नंबर कैसे बढ़ते हैं। हर कुछ मिनट में प्लेयर को कुछ ऐसा ख़रीद पाना चाहिए जो अगले कुछ मिनट तेज़ करे, और हर सेशन ऐसे लक्ष्य के पास ख़त्म होना चाहिए जिसके लिए लौटने का मन करे।

  • ऐसी ग्रोथ जो लंबे समय तक चले। अपग्रेड की कीमतें कमाई से तेज़ बढ़ती हैं, इसलिए हर सीढ़ी थोड़ा ज़्यादा समय लेती है। रीबर्थ स्थायी मल्टीप्लायर के लिए कॉइन रीसेट करता है, और पुराना ज़ोन तेज़ हो जाता है और चढ़ाई नई लगती है।
  • जमा करने को क्या है। खोलने वाले ज़ोन, अंडों से निकले पेट जो कमाई गुणा करते हैं, और अपग्रेड के लिए टूल प्लेयर को एक नंबर के अलावा लक्ष्यों की लिस्ट देते हैं।
  • बड़े नंबर जो पढ़ने लायक रहें। 1500000 नहीं, 1.5M दिखाएँ, और नंबर ऐसे रखें कि सर्वर बड़े होने पर भी उनकी तुलना कर सके।

सिम्युलेटर के लिए सही मॉनेटाइज़ेशन

आम पास कॉइन गुणा करते हैं, पेट के लिए अतिरिक्त स्लॉट देते हैं, एक बार में ज़्यादा अंडे खोलते हैं या ऑटो क्लिक चालू करते हैं। उन्हें गेमपास के रूप में बेचें और सर्वर पर जाँचें। कॉइन पैक developer products हैं। अगर अंडे या रैंडम नतीजे वाली कोई भी चीज़ Robux से या Robux से ख़रीदी करेंसी से ख़रीदी जा सकती है, तो Roblox ख़रीद से पहले संभावना दिखाना ज़रूरी करता है: दुकान बनाने से पहले paid random items (अंग्रेज़ी में) पढ़ें।

प्लेयर को क्या वापस लाता है

सेव की गई प्रोग्रेस, अपडेट में नया ज़ोन या पेट का सेट, डेली रिवॉर्ड, अपडेट के साथ घोषित किए जाने वाले कोड, और रीबर्थ का लीडरबोर्ड। दूसरे जॉनर, हर एक अपने लूप, सिस्टम और बनाने के प्लान के साथ: Roblox गेम जॉनर।

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

Play दबाने से पहले Output विंडो खोलें (Window मेनू, फिर Output)। ज़्यादातर समस्याएँ वहाँ स्क्रिप्ट के नाम और लाइन के साथ चेतावनी या गलती दिखाती हैं।

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

LocalScript उन रिमोट का इंतज़ार करती है जिन्हें SimulatorService शुरू होने पर बनाती है। जाँचें कि SimulatorService एक Script है, LocalScript नहीं, कि वह ServerScriptService में है और Output में उसकी कोई गलती नहीं है। SimulatorConfig के लिए यही चेतावनी का मतलब है कि मॉड्यूल ReplicatedStorage में नहीं है या उसका नाम अलग है।

बटन कभी नहीं दिखते

स्क्रीन बनाने से पहले LocalScript आपके leaderstats का इंतज़ार करती है। अगर Output में leaderstats पर Infinite yield possible लिखा है, तो SimulatorService ने अभी आपको शुरू नहीं किया। SAVE_PROGRESS = true के साथ वह PlayerData का इंतज़ार करती है, इसलिए जाँचें कि PlayerData ServerScriptService में है और बिना गलती के लोड होता है।

Output में लिखा है "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"

सेव चालू है, लेकिन PlayerData मॉड्यूल में अभी नए फ़ील्ड नहीं हैं। उन्हें उसके DEFAULTS में जोड़ें, जैसे स्टेप 4 में, और फिर Play दबाएँ।

"+1" दिखते हैं, लेकिन कॉइन नहीं बढ़ते

सर्वर क्लिक नहीं गिन रहा। या तो SimulatorService में गलती है (Output में उसका लाल टेक्स्ट ढूँढें), या क्लिक MAX_CLICKS_PER_SECOND की इजाज़त से तेज़ आ रहे हैं। अगर प्लेयर सामान्य खेल में सीमा से टकराते हैं, तो SimulatorConfig में उसे बढ़ाएँ।

स्टेटस लाइन में लिखा है "No answer from the server. Try again."

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

स्क्रीन का कॉइन काउंटर और प्लेयर लिस्ट अलग नंबर दिखाते हैं

कोई और स्क्रिप्ट भी leaderstats फ़ोल्डर बनाती है, इसलिए हर प्लेयर के पास दो हैं, और LocalScript दूसरा पढ़ सकती है। अतिरिक्त स्क्रिप्ट हटाएँ: SimulatorService ख़ुद Coins और Rebirths बनाती है।

हर बार दोबारा आने पर कॉइन रीसेट होते हैं

सेव बंद है। स्टेप 4 पूरा करें। अगर वह चालू है और Studio में कॉइन फिर भी रीसेट होते हैं, तो जाँचें कि टेस्ट कॉपी में Studio का API सर्विस एक्सेस चालू है, जैसा DataStore ट्यूटोरियल समझाता है।

RoCode से बनाएँ

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

आप लिखते हैं

एक क्लिकर सिम्युलेटर बनाओ: एक बड़ा Click बटन जो मेरे Click Power लेवल गुणा (रीबर्थ + 1) के बराबर कॉइन दे, एक Upgrade बटन जिसकी कीमत 10 कॉइन हो और हर लेवल पर 1.5 गुना बढ़े, और 1,000 कॉइन का Rebirth बटन जो कॉइन और अपग्रेड रीसेट करे। नंबर सर्वर पर रखो और क्लिक सेकंड में 15 तक सीमित करो। मेरे पास पहले से PlayerData मॉड्यूल है।

RoCode करता है
  • पहले Search Scripts और Read Script से आपका PlayerData मॉड्यूल और कोई भी leaderstats स्क्रिप्ट पढ़ सकता है, ताकि दूसरी सेव स्क्रिप्ट लिखने की जगह आपके मौजूदा डेटा में फ़ील्ड जोड़े
  • Build UI के HUD लेआउट (प्लगइन 3.9 या नए के साथ, सिम्युलेटर स्टाइल में) से स्क्रीन का ढाँचा बना सकता है या LocalScript में बटन बना सकता है, और Create Script से ModuleScript, सर्वर Script और LocalScript लिखता है
  • उसे अपनी लिखी हर स्क्रिप्ट का कंपाइल Check Script से जाँचने को कहा गया है, जो उसे Studio में बिना चलाए कंपाइल करता है
  • बदलावों के हर बैच से पहले और बाद में undo पॉइंट रखता है, इसलिए Ctrl+Z एक बार में एक बैच वापस करता है

RoCode गेमपास और developer products नहीं बना सकता, न ही पेट के मेश और आइकन अपलोड कर सकता है: यह Creator Hub और Studio में होता है। प्लगइन 3.9.11 या नए के साथ RoCode Studio में आपके गेम का playtest चला सकता है और सब कुछ काम करता है यह जाँचने के लिए टेस्ट कैरेक्टर चला सकता है, और प्लगइन 3.9.15 या नए के साथ टेस्ट कैरेक्टर स्क्रीन बटन दबा सकता है, जैसे Click दबाकर जाँचना कि Coins बढ़े। वह ख़ुद तय करता है कि playtest कब चलाना है, हर बिल्ड में 2 तक और अपने सुधार की जाँच के लिए 1, और सिर्फ़ वही जाँचता है जो उसने चुना, इसलिए लूप ख़ुद जाँचें। पूरा सिम्युलेटर कई प्रॉम्प्ट में बनता है, एक बार में एक सिस्टम: RoCode के साथ हर प्रॉम्प्ट में एक सिस्टम कैसे बनाएँ। RoCode, Studio से कैसे जुड़ता है।

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

Roblox में बिना स्क्रिप्ट के सिम्युलेटर कैसे बनाएं?

काम करने वाले सिम्युलेटर को स्क्रिप्ट चाहिए: किसी को कॉइन जोड़ने, कीमतें जाँचने और प्रोग्रेस सेव करनी है। आप इस गाइड की तीन स्क्रिप्ट जैसी हैं वैसी पेस्ट करके सिर्फ़ SimulatorConfig के नंबर बदल सकते हैं, या उन्हें Creator Store के किट, किसी प्लगइन या AI एजेंट से बनवाकर जाँच सकते हैं कि कॉइन सर्वर तय करता है। विकल्प।

रीबर्थ सिस्टम कैसे काम करता है?

रीबर्थ आपके कॉइन और अपग्रेड को स्थायी बोनस से बदलता है। इस गाइड में पहला रीबर्थ 1,000 कॉइन का है; यह Coins को 0, Click Power को लेवल 1 करता है और Rebirths में 1 जोड़ता है, और इसके बाद हर क्लिक Rebirths + 1 से गुणा होता है। हर रीबर्थ पिछले से तीन गुना महँगा है।

स्ट्रेंथ या जिम सिम्युलेटर कैसे बनाएं?

प्लेयर को एक Tool दें, जैसे डम्बल, जिसकी LocalScript Tool.Activated पर वही Click रिमोट कॉल करे। सर्वर इनाम ठीक वैसे ही गिनता है जैसे बटन क्लिक पर। सर्वर की क्लिक सीमा उठाने की रफ़्तार तक घटाएँ, ताकि स्क्रिप्ट प्लेयर से ज़्यादा न कमा सके। स्क्रिप्ट डम्बल वाले वर्ज़न सेक्शन में है।

सिम्युलेटर में कौन से सिस्टम चाहिए?

पहले कमाई, अपग्रेड और रीबर्थ का लूप, फिर सेव, फिर पेट या कोई और कलेक्शन जो कमाई गुणा करे, रीबर्थ के पीछे ज़ोन, लीडरबोर्ड, डेली रिवॉर्ड और कोड, और सबसे आख़िर में गेमपास। बनाने के क्रम में हर एक के लिए गाइड है।

रीबर्थ में कितना समय लगना चाहिए?

इतना लंबा कि प्लेयर पहले कुछ अपग्रेड ख़रीदें, और इतना छोटा कि पहले सेशन में एक तक पहुँच जाएँ। इस गाइड के नंबरों के साथ सेकंड में 5 क्लिक पर पहला रीबर्थ लगभग 1.2 मिनट में आता है; REBIRTH_BASE_COST को 10,000 करने पर लगभग 8 मिनट। और सेटिंग रफ़्तार वाली तालिका में हैं।

ऑटो क्लिकर से कैसे बचें?

सर्वर हर एक सेकंड की विंडो में प्रति प्लेयर 15 से ज़्यादा क्लिक नहीं गिनता और बाकी नज़रअंदाज़ करता है। इस सीमा से नीचे स्क्रिप्ट तेज़ प्लेयर जैसी ही दिखती है, इसलिए इकॉनमी को यही सीमा बचाती है। आप ऑटो क्लिक को सर्वर पर चलने वाले गेमपास के रूप में भी बेच सकते हैं।

दोबारा आने पर कॉइन रीसेट क्यों होते हैं?

अभी उन्हें कुछ भी सेव नहीं करता। DataStore ट्यूटोरियल का PlayerData मॉड्यूल जोड़ें, उसके DEFAULTS में PowerLevel और Rebirths जोड़ें और SimulatorService में SAVE_PROGRESS = true सेट करें, जैसे स्टेप 4 में।

सिम्युलेटर में पेट कैसे जोड़ें?

हर पेट को एक मल्टीप्लायर बनाएँ जो सर्वर क्लिक पर लगाए। अंडे सर्वर पर weighted रैंडम चुनाव से खोलें, प्लेयर के पेट की id उसके बाकी डेटा के साथ सेव करें और उन्हें इन्वेंटरी GUI में दिखाएँ, जैसे इन्वेंटरी गाइड में।

क्या बेहतर है: पार्ट पर क्लिक या बटन पर?

दोनों ठीक हैं। स्क्रीन बटन फ़ोन पर आसान है, और ClickDetector वाला पार्ट ऐसे गेम के लिए ठीक है जहाँ सब कुछ दुनिया में होता है। Roblox डॉक्यूमेंटेशन के अनुसार सर्वर ClickDetector इवेंट की बिल्कुल जाँच नहीं करता, इसलिए इन क्लिक की रफ़्तार भी सर्वर पर उसी तरह सीमित करें।

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

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

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

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