संक्षेप में
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 रिमोट कॉल कर सकता है: डम्बल वाला वर्ज़न। फिर नीचे दिए बनाने के क्रम से सिस्टम जोड़ें।
इस पेज पर
सिम्युलेटर का मुख्य लूप कैसे बना है
सिम्युलेटर तीन कामों का लूप है। प्लेयर करेंसी कमाने के लिए बार-बार कुछ आसान करता है, उसे ऐसे अपग्रेड पर ख़र्च करता है जो उसे तेज़ी से लाएँ, और जब अपग्रेड महँगे हो जाएँ तो रीबर्थ करता है: हमेशा रहने वाले बोनस के बदले कॉइन और अपग्रेड छोड़ देता है और फिर से चढ़ता है, इस बार तेज़ी से। दूसरे सिम्युलेटर में क्लिक की जगह डम्बल उठाते हैं, खुदाई करते हैं या चीज़ें जमा करते हैं, लेकिन नीचे लूप वही है।
| काम | कीमत | क्या देता है | कौन तय करता है |
|---|---|---|---|
| क्लिक | कुछ नहीं | कॉइन, Click Power × (Rebirths + 1) के बराबर | सर्वर, जो हर एक सेकंड की विंडो में 15 से ज़्यादा क्लिक नहीं गिनता |
| अपग्रेड | 10 कॉइन, फिर हर लेवल पर पिछली कीमत का 1.5 गुना | Click Power का एक और लेवल, 50वें तक | सर्वर, कीमतों की अपनी कॉपी से |
| रीबर्थ | 1,000 कॉइन, फिर हर रीबर्थ पर पिछली कीमत का 3 गुना | कॉइन वापस 0 और Click Power वापस लेवल 1, साथ में मल्टीप्लायर में स्थायी +1 | सर्वर |
हर नंबर सर्वर पर रहता है। प्लेयर का डिवाइस बटन दिखाता है और अनुरोध करता है ("मैंने क्लिक किया", "मुझे अपग्रेड चाहिए"), और सर्वर तय करता है कि उसकी कीमत क्या है और वह हो सकता है या नहीं। जिन क्लिकर स्क्रिप्ट को तोड़ा जाता है, वे अक्सर LocalScript में कॉइन जोड़ती हैं या क्लाइंट को बताने देती हैं कि कितने कॉइन जोड़ने हैं।
| हिस्सा | कहाँ है | क्या करता है |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | क्लिक की कीमत, अपग्रेड की कीमत और रीबर्थ की कीमत के लिए दाम, सीमाएँ और फ़ॉर्मूले। दोनों तरफ़ इसे पढ़ती हैं। |
Script SimulatorService | ServerScriptService | हर प्लेयर के नंबर रखती है, क्लिक, अपग्रेड और रीबर्थ संभालती है और leaderstats भरती है। |
Folder SimulatorRemotes | ReplicatedStorage (इसे SimulatorService बनाती है) | RemoteEvent Click और RemoteFunction BuyUpgrade और Rebirth। |
LocalScript SimulatorClient | StarterPlayerScripts | बटन बनाती है, क्लिक और अनुरोध भेजती है और सर्वर के नंबर दिखाती है। |
ModuleScript PlayerData (वैकल्पिक) | ServerScriptService | आने-जाने के बीच प्रोग्रेस सेव करता है। यह DataStore ट्यूटोरियल से लिया गया है और सिर्फ़ स्टेप 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 बटन के लिए कीमतें इसी से लेती है, इसलिए हर बदलाव एक ही जगह एक ही सुधार है।
- Explorer में ReplicatedStorage पर कर्सर ले जाएँ, + बटन दबाएँ और एक ModuleScript डालें।
- उसका नाम बदलकर
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 रीबर्थ |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
रीबर्थ की कीमत 1,000 कॉइन है, फिर 3,000, फिर 9,000, क्योंकि rebirthCost हर बार कीमत को 3 से गुणा करता है। एक रीबर्थ के बाद हर क्लिक दोगुना होता है, दो के बाद तिगुना, और इसी तरह आगे।
इन नंबरों के साथ रीबर्थ में कितना समय लगता है
फ़ॉर्मूले तय करते हैं कि लूप कितना लंबा है, इसलिए प्लेयर से पहले नंबर गिन लेना अच्छा है। तालिका मानती है कि प्लेयर जैसे ही रीबर्थ का ख़र्च उठा सके, रीबर्थ करता है, और बाकी समय Click Power का अगला लेवल तब ख़रीदता है जब वह उसे ख़रीद सके और वह रीबर्थ से सस्ता हो। समय नई शुरुआत से गिना जाता है, इसलिए आख़िरी कॉलम 3 रीबर्थ तक का कुल समय है।
REBIRTH_BASE_COST | रीबर्थ 1 | रीबर्थ 2 | रीबर्थ 3 |
|---|---|---|---|
| 1,000 (यह गाइड) | 1.2 | 2.7 | 4.8 |
| 5,000 | 4.3 | 10.1 | 18.3 |
| 10,000 | 8.2 | 16.9 | 33.2 |
| 25,000 | 16.7 | 40.1 | 74.5 |
| 50,000 | 32.8 | 68.8 | 137.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 रखें और सामग्री इस कोड से बदलें:
-- हर नंबर की मालिक: क्लिक यहाँ कॉइन लाते हैं, अपग्रेड और रीबर्थ यहाँ ख़रीदे जाते हैं,
-- और 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 बटन और सर्वर के जवाबों के लिए एक स्टेटस लाइन। यह ख़ुद कभी कोई नंबर नहीं बदलती।
- Explorer में StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ और
SimulatorClientनाम की एक LocalScript डालें। - उसकी सामग्री नीचे के कोड से बदलें और Play दबाएँ।
-- सिम्युलेटर के बटन बनाती है और सर्वर के नंबर दिखाती है। ख़ुद उन्हें कभी नहीं बदलती।
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 सेकंड में ऑटोसेव करता है, प्लेयर के जाने और सर्वर बंद होने पर सेव करता है, और उस प्लेयर को कभी सेव नहीं करता जिसका डेटा लोड नहीं हुआ।
- ServerScriptService में
PlayerDataModuleScript जोड़ने के लिए DataStore ट्यूटोरियल का स्टेप 1 पूरा करें। Studio में सेव जाँचने के लिए गेम की टेस्ट कॉपी में Studio का API सर्विस एक्सेस चालू करें, जैसा उसका पहला सेक्शन समझाता है। SimulatorService ख़ुद require से मॉड्यूल जोड़ती है, इसलिए ट्यूटोरियल कीMainस्क्रिप्ट की यहाँ ज़रूरत नहीं। - PlayerData में
DEFAULTSटेबल मेंCoins = 0,के बगल मेंPowerLevel = 1,औरRebirths = 0,जोड़ें। - उसी मॉड्यूल में
Dataटाइप मेंPowerLevel: number,औरRebirths: number,जोड़ें, ताकि strict type checking नए फ़ील्ड के बारे में जाने। - 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 क्या करती है |
|---|---|---|
| लूप में जितना तेज़ हो सके 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 वापस करें।
- Play दबाएँ। स्क्रीन के ऊपर 0 coins लिखा है, हरे बटन पर Upgrade: 10 और नारंगी पर Rebirth: 1.0K।
- बैंगनी Click! बटन दस बार दबाएँ। हर क्लिक सुनहरा +1 दिखाता है, और प्लेयर लिस्ट में Coins 1 बढ़ता है।
- Upgrade दबाएँ। कॉइन 0 पर लौटते हैं, स्टेटस लाइन "Click Power is now level 2." के साथ हरी हो जाती है, और बटन पर अब Upgrade: 15 है। अब से हर क्लिक 2 कॉइन देता है।
- बिना क्लिक किए Rebirth दबाएँ। स्टेटस लाइन में "You need 1000 more coins to rebirth." लिखा आता है, और कुछ नहीं बदलता।
- 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 पर वापस करें। - रफ़्तार सीमा देखने के लिए SimulatorConfig में
MAX_CLICKS_PER_SECONDको 2 करें और तेज़ी से क्लिक करें। "+N" दिखते रहते हैं, लेकिन Coins सेकंड में ज़्यादा से ज़्यादा 2 क्लिक की कीमत जितने बढ़ते हैं। 15 वापस करें। - Studio के Device Simulator में एक फ़ोन चुनें (यह Studio बीटा है; पुराना Device Emulator भी चलेगा) और Play दबाएँ। जाँचें कि Click बटन न कॉइन काउंटर पर चढ़ता है, न Upgrade और Rebirth बटन पर, और कि Upgrade दबाने पर स्टेटस लाइन दिखती है और बटन से ढकती नहीं।
- Playtest के दौरान गेमपैड जोड़ें या Studio में Controller Emulator खोलें (Emulation टैब पर Controller), Select दबाएँ और जाँचें कि तीनों बटन तक पहुँचकर उन्हें A से दबाया जा सकता है।
- सेव चालू (स्टेप 4) और फिर से
SAVE_PROGRESS = trueके साथ कुछ कॉइन कमाएँ, Stop दबाएँ, फिर दोबारा Play। आपके Coins, Click Power लेवल और Rebirths वापस आ जाएँगे।
जिम या खदान वाला सिम्युलेटर बनाएँ
कई सिम्युलेटर बटन की जगह दुनिया में कोई काम रखते हैं: डम्बल उठाना, गैंती चलाना, हवा में तलवार घुमाना। नीचे वही क्लिक है। एक Tool वही Click रिमोट कॉल कर सकता है, इसलिए SimulatorService, उसकी कीमतें और उसकी रफ़्तार सीमा जैसी हैं वैसी रहती हैं।
- Explorer में StarterPack पर कर्सर ले जाएँ, एक Tool डालें और उसका नाम
Dumbbellरखें। उसमेंHandleनाम का एक Part डालें, उसे डम्बल का आकार दें और Anchored से टिक हटाएँ, जैसा तलवार गाइड के Tool वाले स्टेप में है। - Tool में
LiftClientनाम की एक LocalScript डालें और नीचे का कोड पेस्ट करें। - Play दबाएँ, डम्बल लें और क्लिक करें। हर बार उठाने पर कॉइन आपके Click Power जितने बढ़ते हैं, बिल्कुल बटन की तरह।
-- 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 करें। यह वह क्रम है जो हम सुझाते हैं, हर स्टेप के लिए गाइड के साथ।
| क्रम | सिस्टम | गाइड | अभी क्यों |
|---|---|---|---|
| 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 मॉड्यूल है।
- पहले 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 Creator Docs: Securing the client-server boundary (अंग्रेज़ी में). रफ़्तार सीमा, गेम के अंदर दुकान का उदाहरण और ClickDetector इवेंट
- Roblox Creator Docs: Security and cheat mitigation tactics (अंग्रेज़ी में). exploiter अपने डिवाइस पर क्या नियंत्रित करता है
- Roblox Creator Docs: Remote events and callbacks (अंग्रेज़ी में). FireServer, प्लेयर पैरामीटर, InvokeServer और OnServerInvoke
- Roblox Creator Docs: Leaderboards (अंग्रेज़ी में). leaderstats और ordered data stores
- Roblox Creator Docs: Data store error codes and limits (अंग्रेज़ी में). सामान्य और ordered data stores के लिए प्रति सर्वर लिखने की सीमाएँ
- Roblox Engine API: GuiButton (अंग्रेज़ी में). कंप्यूटर, फ़ोन और कंसोल पर Activated
- Roblox Engine API: GuiService (अंग्रेज़ी में). AutoSelectGuiEnabled और गेमपैड से GUI ऑब्जेक्ट चुनना
- Roblox Engine API: IntValue (अंग्रेज़ी में). 64-बिट रेंज और 2^53 से ऊपर सटीकता का नुकसान
- Roblox Creator Docs: Size modifiers and constraints (अंग्रेज़ी में). UIAspectRatioConstraint और UISizeConstraint
- Roblox Creator Docs: Studio testing modes (अंग्रेज़ी में). Device Simulator और Controller Emulator
कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।