Tutorial · Gamesystemen

Hoe maak je een simulator in Roblox

Bijna alle simulators draaien op dezelfde lus: je doet iets simpels en krijgt valuta, je geeft die uit aan upgrades die je sneller valuta opleveren, en daarna doe je een rebirth om opnieuw te beginnen met een blijvende vermenigvuldiger. In deze handleiding bouwen we die lus als clicker van drie scripts waarin de server elk getal bepaalt, en we slaan de voortgang op met de module PlayerData uit de DataStore-tutorial. Heb je nog nooit een game in Studio gemaakt, maak dan eerst een kort parcours met munten.

Bijgewerkt 20 november 202627 min lezenAuteur:

In het kort

Een simulator in Roblox is één lus: klik om munten te verdienen, geef ze uit aan upgrades die meer opleveren en doe daarna een rebirth voor een blijvende vermenigvuldiger. Zet de prijzen in een ModuleScript in ReplicatedStorage. Eén Script in ServerScriptService houdt voor elke speler Coins, Click Power en Rebirths bij, telt niet meer dan 15 klikken per seconde van de RemoteEvent Click en verkoopt upgrades en rebirths via een RemoteFunction nadat de prijs is gecontroleerd. Een LocalScript toont de knoppen Click, Upgrade en Rebirth. Met de getallen uit deze handleiding bereikt een speler die 5 keer per seconde klikt de eerste rebirth in ongeveer 1,2 minuut, en de tempotabel laat zien wat je verandert voor een langere opbouw.

  • Een klik stuurt niets mee behalve de klik zelf. Hoeveel hij waard is, berekent de server, dus een aangepaste client kan zichzelf geen munten geven.
  • Sla de hele tabel op met een timer en als de speler weggaat, niet bij elke klik. Roblox staat elke server 60 + 40 × spelers schrijfacties naar de datastore per minuut toe.
  • Kun je niet scripten? Dezelfde lus kan ook gebouwd worden met een kit uit de Creator Store, een plugin of een AI-agent. Controleer dat de server de munten bepaalt: opties.
  • Wil je een gym of mijn in plaats van een knop? Een Tool kan dezelfde remote Click aanroepen: de halterversie. Voeg daarna systemen toe volgens de bouwvolgorde hieronder.
Op deze pagina
  1. Hoe het werkt
  2. 1. Instellingenmodule
  3. 2. Serverscript
  4. 3. Knoppen
  5. 4. Opslaan
  6. Waarom de server beslist
  7. 5. Testen
  8. De halterversie
  9. Bouwvolgorde
  10. Zonder scripten
  11. Uitbreiden
  12. Het genre
  13. Common errors
  14. Met RoCode
  15. Veelgestelde vragen
  16. Bronnen en verder lezen

Hoe de kernlus van een simulator werkt

IllustratieDe speler koopt Click Power-level 2 voor 10 munten, verzamelt daarna (versneld) 1.000 munten en doet een rebirth: munten en upgrades worden gereset, en elke klik is x2 waard.

Een simulator is een lus van drie acties. De speler doet steeds weer iets simpels om valuta te verdienen, geeft die uit aan upgrades die het sneller opleveren, en als de upgrades duur worden, doet hij een rebirth: hij levert munten en upgrades in voor een bonus die voor altijd blijft, en klimt daarna opnieuw, maar sneller. In andere simulators til je halters, graaf je of verzamel je spullen in plaats van te klikken, maar de lus eronder is hetzelfde.

De drie acties in de lus van deze handleiding
ActieWat het kostWat het oplevertWie beslist
KlikNietsMunten gelijk aan Click Power × (Rebirths + 1)De server, die niet meer dan 15 klikken telt in elk venster van een seconde
Upgrade10 munten, daarna per level 1,5 keer de vorige prijsEen level Click Power erbij, tot level 50De server, op basis van zijn eigen kopie van de prijzen
Rebirth1.000 munten, daarna per rebirth 3 keer de vorige prijsMunten terug naar 0 en Click Power terug naar level 1, plus een blijvende +1 op de vermenigvuldigerDe server

Elk getal leeft op de server. Het apparaat van de speler tekent de knoppen en vraagt ("ik heb geklikt", "ik wil een upgrade"), en de server beslist wat het kost en of het mag. Clickerscripts die gehackt worden, tellen vaak munten op in een LocalScript of laten de client sturen hoeveel munten erbij moeten.

Waaruit de simulator bestaat
OnderdeelWaar het staatWat het doet
ModuleScript SimulatorConfigReplicatedStoragePrijzen, limieten en formules voor de waarde van een klik, de upgradeprijs en de rebirthprijs. Beide kanten lezen hem.
Script SimulatorServiceServerScriptServiceHoudt de getallen van elke speler bij, verwerkt klikken, upgrades en rebirths en vult leaderstats.
Folder SimulatorRemotesReplicatedStorage (SimulatorService maakt hem aan)De RemoteEvent Click en de RemoteFunctions BuyUpgrade en Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsBouwt de knoppen, stuurt klikken en verzoeken en toont de getallen van de server.
ModuleScript PlayerData (optioneel)ServerScriptServiceSlaat de voortgang tussen sessies op. Hij komt uit de DataStore-tutorial en is alleen nodig voor stap 4.
De Explorer tijdens het spelen. SimulatorService maakt SimulatorRemotes en de drie remotes aan als de game start, en PlayerData verschijnt pas nadat je in stap 4 opslaan hebt toegevoegd.
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

Stap 1: zet de prijzen en formules in een module

Elk getal dat je misschien wilt bijstellen, gaat in één ModuleScript: wat een klik waard is, wat elke upgrade en rebirth kost en de kliklimiet. De server beslist op basis ervan, en het LocalScript haalt er de prijzen voor de knoppen uit, dus elke wijziging is één aanpassing op één plek.

  1. Ga in de Explorer met je muis over ReplicatedStorage, klik op de knop + en voeg een ModuleScript in.
  2. Hernoem hem naar SimulatorConfig (namen zijn hoofdlettergevoelig) en vervang de inhoud door de code hieronder.
ModuleScript in ReplicatedStorage met de naam SimulatorConfig
-- Alle getallen van de kernlus en de formules die beide kanten gebruiken. De client toont
-- er alleen prijzen mee; de server beslist op basis van zijn eigen kopie.

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- prijs van Click Power-level 2
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- elk level kost 1.5 keer zoveel als het vorige
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- munten voor de eerste rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- elke rebirth kost 3 keer zoveel als de vorige
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- klikken boven dit aantal binnen één seconde worden genegeerd

-- Munten per klik: het Click Power-level keer 1 + het aantal rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Prijs van het volgende Click Power-level
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- Munten die nodig zijn voor de volgende rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

Spelers kunnen een ModuleScript in ReplicatedStorage lezen, dus deze prijzen zijn openbaar. Dat is prima: ze staan toch al op de knoppen. De client en de server draaien elk hun eigen kopie van de module, dus een speler die de getallen op zijn apparaat verandert, verandert niets op de server.

Wat de formules met deze instellingen opleveren
Click Power-levelPrijs volgende levelMunten per klik, geen rebirthsMunten per klik, 1 rebirth
11012
21524
32236
43348
550510

Rebirths kosten 1.000 munten, daarna 3.000, daarna 9.000, omdat rebirthCost de prijs elke keer met 3 vermenigvuldigt. Na één rebirth is elke klik twee keer zoveel waard, na twee rebirths drie keer, enzovoort.

Hoe lang een rebirth duurt met deze getallen

De formules bepalen hoe lang de lus duurt, dus het loont om de getallen door te rekenen voordat spelers dat doen. De tabel gaat ervan uit dat de speler een rebirth doet zodra hij die kan betalen, en verder het volgende Click Power-level koopt als hij het kan betalen en het minder kost dan een rebirth. De tijd telt vanaf een nieuwe start, dus de laatste kolom is de totale tijd tot 3 rebirths.

Minuten vanaf een nieuwe start tot elke rebirth bij 5 klikken per seconde, per REBIRTH_BASE_COST. Berekend met de formules van SimulatorConfig, niet gemeten bij spelers
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1.000 (deze handleiding)1,22,74,8
5.0004,310,118,3
10.0008,216,933,2
25.00016,740,174,5
50.00032,868,8137,8

Zonder rebirths komt Click Power-level 5 na 34 klikken, level 10 na 122 en level 13 na 285. Met de standaardgetallen stopt de speler daarna met upgraden, omdat level 14 1.297 munten kost, meer dan een rebirth van 1.000 munten, en de eerste rebirth komt na 362 klikken in totaal. Bij de serverlimiet van 15 klikken per seconde deel je elke tijd door 3. Verander je een getal in SimulatorConfig, dan veranderen deze tijden mee, dus reken ze opnieuw uit.

De groei afstellen

De twee _GROWTH-getallen bepalen hoe snel de prijzen stijgen. Bij 1,5 kost elke upgrade anderhalf keer zoveel als de vorige, terwijl elk level maar één munt per klik toevoegt (vóór de rebirthvermenigvuldiger), dus elk nieuw level verdient zich steeds langzamer terug. Juist die vertraging maakt een rebirth de moeite waard. Verhoog de groei voor een langere opbouw, verlaag hem voor een snellere, en houd REBIRTH_BASE_COST hoog genoeg zodat spelers een paar upgrades kopen voor de eerste rebirth.

Wil je dat de eerste rebirth na een paar minuten komt in plaats van na ongeveer één, verhoog REBIRTH_BASE_COST dan naar 5.000 of 10.000.

Stap 2: voeg het serverscript toe

Dit Script bezit elk getal. Het maakt de remotes aan, geeft elke speler een map leaderstats met Coins en Rebirths en beantwoordt drie verzoeken. Ga met je muis over ServerScriptService, voeg een Script in, hernoem het naar SimulatorService en vervang de inhoud door deze code:

Script in ServerScriptService met de naam SimulatorService
-- Bezit elk getal: klikken leveren hier munten op, upgrades en rebirths worden hier gekocht,
-- en leaderstats tonen alleen het resultaat.

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

-- false: iedereen begint elke sessie bij nul. true: laden en opslaan via de module PlayerData
-- uit de DataStore-tutorial (voeg eerst PowerLevel = 1 en Rebirths = 0 toe aan zijn DEFAULTS).
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 } = {} -- wanneer het huidige secondevenster van deze speler begon
local clickCount: { [Player]: number } = {} -- klikken die in dit venster geteld zijn

-- Kopieert de getallen van de server naar waar spelers ze zien: leaderstats en één attribuut
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

-- Start een speler met de meegegeven gegevens (nieuwe getallen of een opgeslagen tabel)
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

-- Een klik bevat geen getallen: wat hij waard is, berekent de server
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 -- een autoclicker of een script dat de remote in een lus aanroept
	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
	-- Een rebirth ruilt munten en upgrades in voor een blijvende vermenigvuldiger
	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

-- Startgetallen: nieuwe, of de tabel die de module PlayerData laadt en opslaat
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) -- dezelfde tabel die PlayerData opslaat, dus elke wijziging wordt opgeslagen
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- iedereen van wie de gegevens geladen waren voordat dit script startte
	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 komt bij de speler aan als het attribuut PowerLevel op zijn Player-object, niet als derde waarde in leaderstats, dus de spelerslijst toont alleen Coins en Rebirths. Attributen die de server instelt, repliceren naar het apparaat van de speler; een wijziging die de speler op zijn eigen apparaat maakt, blijft daar.

Klikken en de frequentielimiet

De remote Click stuurt geen argumenten mee. Op de server is de eerste parameter van de handler OnServerEvent altijd de speler die hem aanriep, dus de server weet wie er klikte, pakt zijn Click Power-level en Rebirths en telt clickValue op bij zijn Coins. Er zit niets in het verzoek wat een cheater kan veranderen.

In de beveiligingsgids van Roblox staat dat je nooit alleen op een frequentielimiet op de client moet vertrouwen, en het uitdelen van valuta staat daar bij de acties die je moet beperken. De server telt de klikken van elke speler in vensters van één seconde: de eerste klik opent een venster, en zodra er 15 klikken geteld zijn, worden de rest genegeerd tot er sinds het begin van het venster een seconde voorbij is. Een script dat de remote in een lus aanroept, krijgt niet meer dan 15 getelde klikken per venster. Wil je sneller of langzamer klikken toestaan, verander dan MAX_CLICKS_PER_SECOND in SimulatorConfig.

Upgrades en rebirths

BuyUpgrade en Rebirth zijn RemoteFunctions, zodat de knop op het antwoord kan wachten en het kan tonen. Elke handler haalt de prijs uit de serverkopie van SimulatorConfig, controleert de Coins van de speler en verandert pas daarna iets. Hij geeft true of false terug plus een bericht, bijvoorbeeld "You need 5 more coins.", dat het LocalScript in de statusregel toont.

Tussen de prijscontrole en de wijziging wacht of yieldt niets, dus twee verzoeken van dezelfde speler kunnen niet allebei door de controle komen voordat het eerste de munten heeft afgeschreven. Een rebirth zet Coins op 0 en Click Power op level 1 en telt 1 op bij Rebirths, en de klikformule maakt daar een vermenigvuldiger van Rebirths + 1 van.

De schakelaar SAVE_PROGRESS

Met SAVE_PROGRESS = false begint elke speler bij elke sessie met 0 munten, en dat is wat je wilt zolang je de game bouwt. Stap 4 zet hem aan. Dan wacht het script tot de module PlayerData elke speler heeft geladen en werkt het rechtstreeks met de tabel die die module opslaat, dus elke munt en elke rebirth wordt opgeslagen zonder extra code.

Stap 3: bouw de knoppen

Dit LocalScript bouwt het hele scherm in code: een muntenteller bovenaan, een grote knop Click in het midden, de knoppen Upgrade en Rebirth onderaan en een statusregel voor de antwoorden van de server. Zelf verandert het nooit een getal.

  1. Klap in de Explorer StarterPlayer uit, ga met je muis over StarterPlayerScripts en voeg een LocalScript in met de naam SimulatorClient.
  2. Vervang de inhoud door de code hieronder en druk op Play.
LocalScript in StarterPlayerScripts met de naam SimulatorClient
-- Bouwt de knoppen van de simulator en toont de getallen van de server. Zelf verandert het ze nooit.

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))
-- De knop Click blijft vierkant, schaalt met het scherm en wordt niet groter dan 200 bij 200,
-- zodat hij op een telefoon tussen de muntenteller en de knoppen onderaan past
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()

-- De "+N" die boven de knop opduikt. Het getal is alleen een schatting voor de show;
-- wat een klik echt waard is, bepaalt de server.
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)

De knoppen gebruiken Activated, dat Roblox afvuurt bij een klik met de linkermuisknop op een computer, bij een tik op een telefoon en bij het indrukken van A (of het kruisje) op een gamepad in de UI-navigatiemodus.

Op een gamepad drukt A alleen de geselecteerde knop in. Als GuiService.AutoSelectGuiEnabled aan staat, selecteert de knop Select op de gamepad je schermknoppen; daarna kunnen spelers ertussen wisselen en op A drukken. Wil je dat een gamepadknop meteen klikt, koppel hem dan via ContextActionService en roep er dezelfde remote Click mee aan.

Vier details in het script:

  • De knop Click schaalt mee met het scherm. Zijn grootte is een deel van het scherm, UIAspectRatioConstraint houdt hem vierkant en UISizeConstraint beperkt hem tot 200 bij 200 pixels. Op een monitor is hij 200 pixels breed; op een telefoon krimpt hij en past hij tussen de muntenteller en de knoppen onderaan. Verplaats je onderdelen, houd hem er dan ver vandaan: Rebirth vraagt geen bevestiging, dus een per ongeluk getikte knop kan de munten en upgrades van een speler resetten.
  • De opduikende "+N" is alleen voor de show. Hij gebruikt de clientkopie van de formule. Negeert de server een klik vanwege de frequentielimiet, dan verschijnt "+N" toch, maar veranderen de munten niet.
  • short() maakt grote getallen leesbaar. 1.234 wordt getoond als 1.2K en 5.600.000 als 5.6M. De functie rondt naar beneden af, dus de teller toont nooit meer dan je hebt. Voor getallen groter dan T (biljoenen) voeg je regels toe aan UNITS.
  • Het scherm werkt bij op events. Het luistert naar de waarden Coins en Rebirths en naar het attribuut PowerLevel, dus de prijzen op de knoppen kloppen, hoe de getallen ook veranderen.

Bij de ScreenGui staat ResetOnSpawn op false, zodat hij blijft staan als het personage respawnt. Dat is hier belangrijk: een LocalScript in StarterPlayerScripts wordt één keer naar de speler gekopieerd, bij het joinen, dus het zou het scherm niet opnieuw bouwen.

Stap 4: sla de voortgang op met PlayerData

Op dit moment wordt alles gereset als een speler weggaat. In plaats van een tweede opslagscript koppelt de simulator zich aan de module PlayerData uit de DataStore-tutorial. Die module probeert mislukte verzoeken al opnieuw, slaat elke 180 seconden automatisch op, slaat op als een speler weggaat en als de server afsluit, en slaat nooit een speler op van wie de gegevens niet geladen zijn.

  1. Volg stap 1 van de DataStore-tutorial om de ModuleScript PlayerData aan ServerScriptService toe te voegen. Wil je opslaan in Studio testen, zet dan in een testkopie van de game Studio-toegang tot API-services aan, zoals het eerste deel uitlegt. SimulatorService laadt de module zelf met require, dus het script Main uit de tutorial heb je hier niet nodig.
  2. Voeg in PlayerData PowerLevel = 1, en Rebirths = 0, toe aan de tabel DEFAULTS, naast Coins = 0,.
  3. Voeg in dezelfde module PowerLevel: number, en Rebirths: number, toe aan het type Data, zodat de strikte typecontrole de nieuwe velden kent.
  4. Vervang in SimulatorService local SAVE_PROGRESS = false door local SAVE_PROGRESS = true.

Spelers die opgeslagen werden voordat je de velden toevoegde, krijgen ze automatisch: de functie migrate in PlayerData vult alle velden uit DEFAULTS aan die in de opgeslagen tabel ontbreken, dus ze beginnen met Click Power-level 1 en 0 rebirths en houden hun Coins. Sla je punt 2 over, dan geeft SimulatorService een waarschuwing met de velden die je moet toevoegen en start het de speler niet.

Waarom de simulator in de tabel van PlayerData schrijft

Als opslaan aan staat, kopieert SimulatorService de getallen nergens naartoe. PlayerData.Get(player) geeft de levende tabel terug die de module opslaat, en de simulator verandert Coins, PowerLevel en Rebirths in diezelfde tabel. Elk getal heeft één kopie, en één script schrijft naar de datastore. Twee scripts die dezelfde sleutel opslaan, overschrijven elkaar, en een van de twee kan oude getallen over die van de ander heen opslaan.

Maak niet ook nog leaderstats in de handler Loaded, zoals de DataStore-tutorial voor andere games aanraadt: SimulatorService maakt Coins en Rebirths al uit de geladen tabel. Maakt een leaderboard-script al leaderstats, verwijder dat dan.

Waarom niet bij elke klik opslaan

Roblox staat elke server 60 + 40 × spelers schrijfacties naar een gewone datastore per minuut toe (de rest staat in de tabel met limieten van de DataStore-tutorial). Opslaan bij elke klik bij 15 klikken per seconde is 900 schrijfacties per minuut per speler, veel meer dan de 100 die een server met één speler krijgt. De hele tabel elke 180 seconden opslaan, als een speler weggaat en als de server afsluit, kost maar een paar schrijfacties per speler, en bij een crash verlies je hooguit de voortgang sinds de laatste automatische opslag.

Mislukt het laden, dan laat de module de speler met nieuwe getallen spelen, maar slaat ze nooit op, dus een slechte laadactie kan echte voortgang niet overschrijven. De tutorial legt uit hoe de module dat afhandelt.

Waarom de server elk getal bepaalt

Exploiters hebben hun eigen apparaat in handen. In de beveiligingsgids van Roblox staat dat ze alles in hun lokale kopie van de game kunnen veranderen en elke RemoteEvent of RemoteFunction zo vaak als ze willen kunnen aanroepen, met welke argumenten dan ook. De economie van een simulator is precies zo veilig als zijn serverscript.

Wat een exploiter kan proberen en wat SimulatorService doet
De exploiter probeertAls de client zou beslissenWat SimulatorService doet
Click zo snel mogelijk in een lus aanroepenOneindig veel muntenTelt niet meer dan 15 klikken per venster van een seconde en negeert de rest.
Een aantal munten meesturen met de klikHij kiest zelf zijn beloningNegeert alle argumenten. De waarde van een klik komt uit de getallen van de server.
Een upgrade of rebirth kopen zonder genoeg muntenGratis upgradesVergelijkt de prijs met de Coins op de server en antwoordt "You need N more coins."
Coins in leaderstats op zijn scherm veranderenMunten uitgeven die hij niet heeftLeest leaderstats nooit. Het schrijft er alleen naartoe vanuit zijn eigen tabel.
Het attribuut PowerLevel op zijn Player zettenEen sterkere klikLeest dat attribuut nooit, en de wijziging blijft op het apparaat van de speler.
Rebirth twee keer op hetzelfde moment aanroepenTwee rebirths voor de prijs van éénControleert de prijs bij elke aanroep opnieuw, en tussen controle en wijziging yieldt niets.
De prijzen in zijn kopie van SimulatorConfig veranderenGoedkopere upgradesGebruikt zijn eigen kopie van de module.

De regel geldt voor elke remote in de simulator: stuur wat de speler wil doen, niet wat het waard is. In de RemoteEvent-handleiding wordt het controleren van argumenten van remotes uitgebreider behandeld.

Wat je moet vermijden in gekopieerde clickerscripts

Veelgebruikte trucs uit oude clicker-tutorials en wat deze handleiding in plaats daarvan doet
TrucProbleemDeze handleiding
Een LocalScript telt munten op met leaderstats.Coins.Value += 1De wijziging blijft op één apparaat, en een exploiter heeft zijn eigen apparaat in handenDe server telt de munten op
clickEvent:FireServer(amount)De client kiest zelf zijn beloningClick stuurt geen argumenten mee
Geen frequentielimiet op de serverIn de Roblox-documentatie staat dat je nooit alleen op een limiet op de client moet vertrouwenNiet meer dan 15 klikken per venster van een seconde
SetAsync bij elke klik of upgradeVreet de schrijflimiet van de server opPlayerData slaat elke 180 seconden op, bij weggaan en bij afsluiten. Sla alleen meteen op met PlayerData.SaveNow na iets wat niet verloren mag gaan, zoals een aankoop met Robux.
Een tweede datastorescript alleen voor de simulatorTwee scripts die dezelfde sleutel opslaan, overschrijven elkaarSchrijft in de tabel van PlayerData
Lussen while wait(1) do voor passief inkomenRoblox markeert de globale wait als verouderd, hij is vervangen door task.waittask.wait (zie Uitbreiden)
MouseButton1Click op knoppenBedoeld voor muisklikkenActivated, voor muis, aanraking en gamepad

Stap 5: test het

Loop de punten 1 tot en met 8 door met SAVE_PROGRESS = false in SimulatorService, zodat elke playtest met nieuwe getallen begint. Heb je in stap 4 opslaan al aangezet, zet het dan voorlopig op false en voor punt 9 weer op true.

  1. Druk op Play. Bovenaan het scherm staat 0 coins, op de groene knop Upgrade: 10 en op de oranje Rebirth: 1.0K.
  2. Druk tien keer op de paarse knop Click!. Elke klik toont een gouden +1, en Coins in de spelerslijst gaat met 1 omhoog.
  3. Druk op Upgrade. De munten gaan terug naar 0, de statusregel wordt groen met de tekst "Click Power is now level 2.", en op de knop staat nu Upgrade: 15. Vanaf nu levert elke klik 2 munten op.
  4. Druk zonder te klikken op Rebirth. De statusregel zegt "You need 1000 more coins to rebirth." en er verandert niets.
  5. Wil je de rebirth testen zonder 1.000 keer te klikken, stop dan de test, verander Coins = 0 in Coins = 1000 in de regel tegen het eind van SimulatorService die nieuwe spelers start, en druk op Play. Druk op Rebirth: Coins wordt 0, Rebirths in de spelerslijst wordt 1, de statusregel zegt "Rebirth 1! Every click is now worth x2." en op de knop staat nu Rebirth: 3.0K. Elke klik levert nu 2 munten op bij Click Power-level 1. Zet de regel daarna terug op 0.
  6. Wil je de frequentielimiet zien, zet MAX_CLICKS_PER_SECOND in SimulatorConfig dan op 2 en klik snel. De "+N" blijven verschijnen, maar Coins stijgt hooguit met de waarde van 2 klikken per seconde. Zet hem terug op 15.
  7. Kies een telefoon in de Device Simulator in Studio (dat is een Studio-bèta; de oude Device Emulator werkt ook) en druk op Play. Controleer dat de knop Click niet over de muntenteller of de knoppen Upgrade en Rebirth heen valt, en dat de statusregel bij het indrukken van Upgrade zichtbaar is en niet door een knop bedekt wordt.
  8. Sluit een gamepad aan of open tijdens een playtest de Controller Emulator in Studio (Controller op het tabblad Emulation), druk op Select en controleer dat je alle drie de knoppen kunt bereiken en met A kunt indrukken.
  9. Verdien met opslaan aan (stap 4) en weer SAVE_PROGRESS = true wat munten, druk op Stop en daarna weer op Play. Je Coins, Click Power-level en Rebirths komen terug.

Maak een gym- of mijnsimulator

Veel simulators vervangen de knop door een actie in de wereld: een halter tillen, met een houweel zwaaien, met een zwaard door de lucht zwaaien. Daaronder zit dezelfde klik. Een Tool kan dezelfde remote Click aanroepen, dus SimulatorService, de prijzen en de frequentielimiet blijven zoals ze zijn.

  1. Ga in de Explorer met je muis over StarterPack, voeg een Tool in en noem hem Dumbbell. Voeg er een Part met de naam Handle in, geef hem de vorm van een halter en vink Anchored uit, zoals in de Tool-stappen van de zwaardhandleiding.
  2. Voeg in de Tool een LocalScript met de naam LiftClient in en plak de code hieronder.
  3. Druk op Play, pak de halter en klik. Je munten stijgen per keer tillen met je Click Power, precies zoals met de knop.
LocalScript in Tool Dumbbell in StarterPack met de naam LiftClient
-- LocalScript in de Tool Dumbbell, met de naam LiftClient.
-- Elke keer tillen is een klik: het roept dezelfde remote Click aan als de knop, en de server
-- bepaalt wat het waard is en hoeveel keer tillen er geteld worden.

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 -- tijd tussen twee keer tillen op dit apparaat; de server heeft zijn eigen limiet
local LIFT_ANIMATION_ID = "" -- optioneel: "rbxassetid://" gevolgd door het id van je animatie

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

-- Laad de tilanimatie één keer per personage, via de Animator die Roblox in de Humanoid zet
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() -- geen argumenten: de server berekent de beloning
end)

Voor een tilanimatie maak je die in de Animation Editor met prioriteit Action, publiceer je hem en plak je zijn ID in LIFT_ANIMATION_ID. De animatiestappen uit de zwaardhandleiding werken op dezelfde manier.

  • Stem de serverlimiet af op de actie. LIFT_SECONDS remt alleen eerlijke spelers af: een cheater kan Click vanuit zijn eigen code aanroepen. Is tillen de enige manier om te verdienen, verlaag MAX_CLICKS_PER_SECOND in SimulatorConfig dan naar het echte tempo, bijvoorbeeld naar 2 voor één keer tillen per 0,5 seconde, zodat een script niet meer kan verdienen dan een speler. Reken daarna de tempotabel opnieuw uit: elke tijd daarin gaat uit van 5 klikken per seconde.
  • Houd de knop of verberg hem. De knop Click blijft naast de Tool werken. Wil je hem verbergen, voeg dan clickButton.Visible = false toe direct na de regel in SimulatorClient die clickButton maakt.
  • Alleen op de juiste plek verdienen. Wil je alleen in de gym of de mijn uitbetalen, controleer dan op de server waar het personage is voordat je een klik telt, bijvoorbeeld via de afstand tot een part in die zone. Een controle in LiftClient zou niemand tegenhouden.

Wat nu: de bouwvolgorde van een simulator

Een simulator is een stapel systemen bovenop deze lus. Bouw ze in deze volgorde, zodat elk systeem iets heeft om te vermenigvuldigen, en doe na elk systeem een playtest. Dit is de volgorde die wij aanraden, met een handleiding voor elke stap.

De bouwvolgorde van een simulator in Roblox, van de kernlus naar buiten
VolgordeSysteemHandleidingWaarom nu
1Verdienen, upgraden, rebirthDeze handleidingAl het andere vermenigvuldigt deze lus, dus stel eerst de getallen af met de tempotabel.
2OpslaanDe DataStore-tutorial, daarna stap 4Voortgang die bij opnieuw joinen verdwijnt, is de dood van een simulator. Voeg het toe vóór alles wat spelers kunnen verliezen.
3Eieren en pets als vermenigvuldigersEieren openen en pets die de speler volgenEen tweede doel naast munten: iets om te verzamelen dat elke klik meer waard maakt.
4Zones achter rebirthsUitbreidenEen plek om naartoe te gaan na een rebirth, met betere beloningen die de server controleert.
5LeaderboardsDe leaderboard-handleidingEen wereldwijde top 10 op rebirths geeft de lange klim betekenis.
6Dagelijkse beloningen en codesDagelijkse beloningen en codesRedenen om morgen en na elke update terug te komen.
7GamepassesDe gamepass-handleiding2x munten, autoclick of een extra petslot, met controle op de server. Verkoop ze als de gratis lus al leuk is.

Voor de schermen bevatten de gratis UI-kits voor Roblox schermen in simulatorstijl, samen met de scripts die ze laten werken.

Hoe maak je een simulator zonder scripts te schrijven

Een simulator heeft hoe dan ook scripts nodig: iets moet munten optellen, prijzen controleren en opslaan. Je hoeft ze niet zelf te schrijven:

  • Een simulatorkit uit de Creator Store. Lees de scripts voordat je publiceert en controleer dat munten alleen in een server-Script veranderen, niet in een LocalScript.
  • Een plugin die simulators genereert. Dezelfde controle voor alles wat hij maakt.
  • Een AI-agent in Studio, zoals RoCode, die dezelfde drie scripts kan bouwen in de place die je open hebt.
  • Build in de mobiele Roblox-app. Volgens de Roblox-documentatie maakt hij op basis van een beschrijving eenvoudigere 2D- en 2.5D-games, zoals clickers, en wordt hij geleidelijk per regio uitgerold.

Wat je ook kiest, doe op het resultaat de tests uit stap 5 en de exploitcontroles uit het deel Waarom de server elk getal bepaalt.

Uitbreiden: pets, zones, autoclick en leaderboards

Pets als vermenigvuldigers

Een veelgebruikte opzet: elk pet is een vermenigvuldiger. Bewaar de lijst met pet-id's van een speler in zijn opgeslagen tabel, en laat de server clickValue vermenigvuldigen met de bonus van elk uitgerust pet. Open eieren op de server: de client vraagt om een ei te openen, de server controleert en schrijft de prijs af en kiest dan een pet met een gewogen willekeurige trekking. Laat de client nooit zelf trekken voor een ei of zeggen welk pet eruit kwam. De inventaris-handleiding laat zien hoe je de spullen van een speler bewaart, opslaat en toont, en pets werken op dezelfde manier. De handleiding voor eieren openen bouwt de trekking op de server, en de pet-handleiding laat pets naast hun eigenaar zweven.

Zones die je met rebirths ontgrendelt

Een zone is een deel van de map met betere beloningen achter een barrière. Scherm de beloning af, niet alleen de deur: alles wat binnen de zone uitbetaalt, moet de Rebirths van de speler in de tabel van de server controleren voordat het betaalt. Een deur die een LocalScript voor geschikte spelers opent, is prima voor de show, maar exploiters kunnen parts veranderen en hun personage verplaatsen op hun eigen apparaat.

Autoclick als gamepass

Een autoclicker die je als gamepass verkoopt, moet op de server draaien. Zet de inhoud van de Click-handler in een functie, bijvoorbeeld addClick(player), koppel de remote eraan, en roep hem voor passhouders aan vanuit een serverlus met task.wait(0.5), niet met de verouderde wait. Dan tellen autoclicks mee in dezelfde limiet per seconde als gewone klikken. Controleer het bezit op de server met MarketplaceService:UserOwnsGamePassAsync, zoals de gamepass-handleiding doet voor zijn voordelen. Een 2x-muntenpass werkt net zo: vermenigvuldig clickValue op de server voor de houders. Voordat je een prijs kiest, laat de gratis Robux-belastingcalculator zien hoeveel elke verkoop je oplevert na het aandeel van Roblox, en de DevEx-calculator laat zien hoeveel die Robux in Amerikaanse dollars waard zijn.

Een wereldwijde top 10 op rebirths

leaderstats vergelijkt alleen spelers op dezelfde server. Wil je de Rebirths van alle spelers rangschikken, schrijf ze dan naar een geordende datastore (ordered data store) en lees de bovenste regels terug, zoals in stap 4 van de leaderboard-handleiding. Geordende datastores staan minder schrijfacties toe dan gewone, 30 + 5 × spelers per minuut per server, dus schrijf als een speler weggaat en met een timer.

Heel grote getallen

Getallen in Luau zijn doubles, die ongeveer 15 significante cijfers bewaren. IntValue bewaart gehele getallen tot ongeveer 9,2 triljoen, maar Roblox waarschuwt dat waarden boven 2^53 (ongeveer 9 biljard) in scripts precisie verliezen. Met deze instellingen gaat de rebirthprijs die grens voorbij bij de 29e rebirth. Gaat je game verder, zet de waarden in leaderstats dan om naar NumberValue (vervang IntValue in beide scripts), die veel grotere getallen bewaart met dezelfde precisie van ongeveer 15 cijfers, en voeg achtervoegsels toe aan short().

Waar een simulatorgame op draait

Een simulator is een game van getallen. De klik, de upgrade en de rebirth hierboven zijn de hele lus; of spelers blijven, hangt af van hoe die getallen groeien. Elke paar minuten moet een speler zich iets kunnen veroorloven dat de volgende paar minuten sneller maakt, en elke sessie moet eindigen vlak bij een doel waarvoor je terug wilt komen.

  • Groei die lang genoeg meegaat. Upgradeprijzen stijgen sneller dan het inkomen, dus elke trede duurt net wat langer. Een rebirth reset de munten voor een blijvende vermenigvuldiger, waardoor de oude zone snel wordt en de klim weer nieuw voelt.
  • Iets om te verzamelen. Zones om te ontgrendelen, pets uit eieren die het verdienen vermenigvuldigen, en tools om te upgraden geven spelers een lijst met doelen naast één getal.
  • Grote getallen die leesbaar blijven. Toon 1.5M, niet 1500000, en bewaar getallen zo dat de server ze kan vergelijken, ook als ze groot worden.

Monetisatie die bij een simulator past

Veelvoorkomende passes vermenigvuldigen munten, geven een extra petslot, openen meer eieren tegelijk of zetten autoclick aan. Verkoop ze als gamepasses en controleer ze op de server. Muntenpakketten zijn developer products. Kunnen eieren of andere dingen met een willekeurige uitkomst gekocht worden met Robux of met valuta die je met Robux koopt, dan verplicht Roblox je de kansen vóór de aankoop te tonen: lees paid random items (in het Engels) voordat je de winkel bouwt.

Wat spelers terug laat komen

Opgeslagen voortgang, een nieuwe zone of set pets in updates, dagelijkse beloningen, codes die je samen met updates aankondigt, en een leaderboard op rebirths. Andere genres, elk met hun eigen lus, systemen en bouwplan: gamegenres in Roblox.

Veelvoorkomende fouten en oplossingen

Open het venster Output (menu Window, dan Output) voordat je op Play drukt. De meeste problemen geven daar een waarschuwing of fout met de naam van het script en de regel.

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

Het LocalScript wacht op de remotes die SimulatorService bij het starten aanmaakt. Controleer dat SimulatorService een Script is en geen LocalScript, dat het in ServerScriptService staat en dat er geen fout van in Output staat. Dezelfde waarschuwing voor SimulatorConfig betekent dat de module niet in ReplicatedStorage staat of een andere naam heeft.

De knoppen verschijnen nooit

Het LocalScript wacht op je leaderstats voordat het het scherm bouwt. Staat er in Output Infinite yield possible bij leaderstats, dan heeft SimulatorService je nog niet gestart. Met SAVE_PROGRESS = true wacht het op PlayerData, dus controleer dat PlayerData in ServerScriptService staat en zonder fouten laadt.

Output meldt "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"

Opslaan staat aan, maar de module PlayerData heeft de nieuwe velden nog niet. Voeg ze toe aan zijn DEFAULTS, zoals in stap 4, en druk opnieuw op Play.

Er verschijnen "+1"-tjes, maar de munten stijgen niet

De server telt de klikken niet. Of er zit een fout in SimulatorService (zoek naar rode tekst ervan in Output), of de klikken komen sneller binnen dan MAX_CLICKS_PER_SECOND toestaat. Lopen spelers bij normaal spelen tegen de limiet aan, verhoog hem dan in SimulatorConfig.

De statusregel zegt "No answer from the server. Try again."

De aanroep van BuyUpgrade of Rebirth is mislukt in plaats van een antwoord terug te geven. De gebruikelijke oorzaak is een fout in SimulatorService tijdens het afhandelen van het verzoek, dus zoek de rode fout ervan in Output: daar staat de regel bij.

De muntenteller op het scherm en de spelerslijst tonen verschillende getallen

Een ander script maakt ook een map leaderstats, dus elke speler heeft er twee, en het LocalScript leest misschien de andere. Verwijder het extra script: SimulatorService maakt zelf Coins en Rebirths.

De munten worden bij elke nieuwe sessie gereset

Opslaan staat uit. Volg stap 4. Staat het aan en worden de munten in Studio toch gereset, controleer dan dat in de testkopie Studio-toegang tot API-services aan staat, zoals de DataStore-tutorial uitlegt.

Bouwen met RoCode

Heb je geen zin om dit met de hand te plakken, dan kan RoCode het bouwen in de place die je open hebt. Het is een onafhankelijke AI-agent voor code, niet van Roblox: je beschrijft het systeem in de webchat en de plugin voor Roblox Studio maakt de scripts in je Explorer, dus je hoeft geen code uit een chatvenster te kopiëren.

Jij typt

Maak een clicker-simulator: een grote knop Click die munten geeft gelijk aan mijn Click Power-level keer (rebirths + 1), een knop Upgrade die 10 munten kost en per level 1,5 keer duurder wordt, en een knop Rebirth voor 1.000 munten die munten en upgrades reset. Houd de getallen op de server en beperk klikken tot 15 per seconde. Ik heb al een module PlayerData.

RoCode doet
  • Kan eerst je module PlayerData en een eventueel leaderstats-script lezen met Search Scripts en Read Script, zodat het velden aan je bestaande gegevens toevoegt in plaats van een tweede opslagscript te schrijven
  • Kan een basisscherm maken met de HUD-indeling van Build UI (met plugin 3.9 of nieuwer, in simulatorstijl) of de knoppen in een LocalScript bouwen, en schrijft de ModuleScript, het server-Script en het LocalScript met Create Script
  • Heeft de opdracht elk geschreven script te controleren met Check Script, dat het in Studio compileert zonder het te draaien
  • Zet een ongedaan-maakpunt voor en na elke batch wijzigingen, dus Ctrl+Z draait één batch tegelijk terug

RoCode kan geen gamepasses en developer products maken en geen meshes of peticonen uploaden: dat doe je in de Creator Hub en in Studio. Met plugin 3.9.11 of nieuwer kan RoCode een playtest van je game in Studio starten en een testpersonage besturen om te controleren of alles werkt, en met plugin 3.9.15 of nieuwer kan het testpersonage schermknoppen indrukken, bijvoorbeeld op Click drukken en controleren of Coins is gestegen. Het beslist zelf wanneer het een playtest start, tot 2 per build plus 1 om zijn eigen reparatie te controleren, en test alleen wat het kiest, dus test de lus zelf. Een hele simulator is meerdere prompts, één systeem tegelijk: zo bouw je met RoCode één systeem per prompt. Hoe RoCode verbinding maakt met Studio.

Veelgestelde vragen

Hoe maak je een simulator in Roblox zonder scripts?

Een werkende simulator heeft scripts nodig: iets moet munten optellen, prijzen controleren en voortgang opslaan. Je kunt de drie scripts uit deze handleiding zo plakken en alleen de getallen in SimulatorConfig veranderen, of ze laten maken door een kit uit de Creator Store, een plugin of een AI-agent en controleren dat de server de munten bepaalt. Opties.

Hoe werkt een rebirthsysteem?

Een rebirth ruilt je munten en upgrades in voor een blijvende bonus. In deze handleiding kost de eerste rebirth 1.000 munten; hij zet Coins op 0, Click Power op level 1 en telt 1 op bij Rebirths, en daarna wordt elke klik vermenigvuldigd met Rebirths + 1. Elke rebirth kost drie keer zoveel als de vorige.

Hoe maak je een kracht- of gymsimulator?

Geef spelers een Tool, bijvoorbeeld een halter, waarvan het LocalScript bij Tool.Activated dezelfde remote Click aanroept. De server berekent de beloning precies zoals bij een klik op de knop. Verlaag de kliklimiet op de server naar het tiltempo, zodat een script niet meer kan verdienen dan een speler. Het script staat in het deel de halterversie.

Welke systemen heeft een simulator nodig?

Eerst de lus van verdienen, upgraden en rebirth, daarna opslaan, daarna pets of een andere verzameling die het verdienen vermenigvuldigt, zones achter rebirths, leaderboards, dagelijkse beloningen en codes, en helemaal als laatste gamepasses. In de bouwvolgorde staat voor elk een handleiding.

Hoe lang moet een rebirth duren?

Lang genoeg dat spelers eerst een paar upgrades kopen, en kort genoeg dat ze er in de eerste sessie één halen. Met de getallen van deze handleiding komt de eerste rebirth na ongeveer 1,2 minuut bij 5 klikken per seconde; verhoog je REBIRTH_BASE_COST naar 10.000, dan is dat ongeveer 8 minuten. Meer instellingen staan in de tempotabel.

Hoe bescherm je je game tegen autoclickers?

De server telt niet meer dan 15 klikken per speler in elk venster van een seconde en negeert de rest. Onder die limiet ziet een script er hetzelfde uit als een snelle speler, dus het is juist de limiet die de economie beschermt. Je kunt autoclick ook verkopen als gamepass die op de server draait.

Waarom worden de munten gereset als ik opnieuw join?

Nog niets slaat ze op. Voeg de module PlayerData uit de DataStore-tutorial toe, voeg PowerLevel en Rebirths toe aan zijn DEFAULTS en zet SAVE_PROGRESS = true in SimulatorService, zoals in stap 4.

Hoe voeg je pets toe aan een simulator?

Maak van elk pet een vermenigvuldiger die de server op klikken toepast. Open eieren op de server met een gewogen willekeurige keuze, sla de pet-id's van de speler op samen met de rest van zijn gegevens en toon ze in een inventaris-GUI, zoals in de inventaris-handleiding.

Wat is beter: op een part klikken of op een knop?

Allebei werkt. Een schermknop is handig op telefoons, en een part met een ClickDetector past bij een game waarin alles in de wereld gebeurt. Volgens de Roblox-documentatie controleert de server ClickDetector-events helemaal niet, dus beperk de frequentie van die klikken op dezelfde manier op de server.

Bronnen en verder lezen

Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.

Probeer RoCode in je eigen game.

Elke dag gratis credits, geen creditcard nodig. Installeer de plugin, beschrijf een functie en kijk wat er in Studio verschijnt.