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
Hoe de kernlus van een simulator werkt
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.
| Actie | Wat het kost | Wat het oplevert | Wie beslist |
|---|---|---|---|
| Klik | Niets | Munten gelijk aan Click Power × (Rebirths + 1) | De server, die niet meer dan 15 klikken telt in elk venster van een seconde |
| Upgrade | 10 munten, daarna per level 1,5 keer de vorige prijs | Een level Click Power erbij, tot level 50 | De server, op basis van zijn eigen kopie van de prijzen |
| Rebirth | 1.000 munten, daarna per rebirth 3 keer de vorige prijs | Munten terug naar 0 en Click Power terug naar level 1, plus een blijvende +1 op de vermenigvuldiger | De 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.
| Onderdeel | Waar het staat | Wat het doet |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Prijzen, limieten en formules voor de waarde van een klik, de upgradeprijs en de rebirthprijs. Beide kanten lezen hem. |
Script SimulatorService | ServerScriptService | Houdt de getallen van elke speler bij, verwerkt klikken, upgrades en rebirths en vult leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (SimulatorService maakt hem aan) | De RemoteEvent Click en de RemoteFunctions BuyUpgrade en Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | Bouwt de knoppen, stuurt klikken en verzoeken en toont de getallen van de server. |
ModuleScript PlayerData (optioneel) | ServerScriptService | Slaat de voortgang tussen sessies op. Hij komt uit de DataStore-tutorial en is alleen nodig voor stap 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
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.
- Ga in de Explorer met je muis over ReplicatedStorage, klik op de knop + en voeg een ModuleScript in.
- Hernoem hem naar
SimulatorConfig(namen zijn hoofdlettergevoelig) en vervang de inhoud door de code hieronder.
-- 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.
| Click Power-level | Prijs volgende level | Munten per klik, geen rebirths | Munten per klik, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
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.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1.000 (deze handleiding) | 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 |
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:
-- 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.
- Klap in de Explorer StarterPlayer uit, ga met je muis over StarterPlayerScripts en voeg een LocalScript in met de naam
SimulatorClient. - Vervang de inhoud door de code hieronder en druk op Play.
-- 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,
UIAspectRatioConstrainthoudt hem vierkant enUISizeConstraintbeperkt 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 aanUNITS.- 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.
- Volg stap 1 van de DataStore-tutorial om de ModuleScript
PlayerDataaan 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 scriptMainuit de tutorial heb je hier niet nodig. - Voeg in PlayerData
PowerLevel = 1,enRebirths = 0,toe aan de tabelDEFAULTS, naastCoins = 0,. - Voeg in dezelfde module
PowerLevel: number,enRebirths: number,toe aan het typeData, zodat de strikte typecontrole de nieuwe velden kent. - Vervang in SimulatorService
local SAVE_PROGRESS = falsedoorlocal 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.
| De exploiter probeert | Als de client zou beslissen | Wat SimulatorService doet |
|---|---|---|
| Click zo snel mogelijk in een lus aanroepen | Oneindig veel munten | Telt niet meer dan 15 klikken per venster van een seconde en negeert de rest. |
| Een aantal munten meesturen met de klik | Hij kiest zelf zijn beloning | Negeert alle argumenten. De waarde van een klik komt uit de getallen van de server. |
| Een upgrade of rebirth kopen zonder genoeg munten | Gratis upgrades | Vergelijkt de prijs met de Coins op de server en antwoordt "You need N more coins." |
| Coins in leaderstats op zijn scherm veranderen | Munten uitgeven die hij niet heeft | Leest leaderstats nooit. Het schrijft er alleen naartoe vanuit zijn eigen tabel. |
| Het attribuut PowerLevel op zijn Player zetten | Een sterkere klik | Leest dat attribuut nooit, en de wijziging blijft op het apparaat van de speler. |
| Rebirth twee keer op hetzelfde moment aanroepen | Twee rebirths voor de prijs van één | Controleert de prijs bij elke aanroep opnieuw, en tussen controle en wijziging yieldt niets. |
| De prijzen in zijn kopie van SimulatorConfig veranderen | Goedkopere upgrades | Gebruikt 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
| Truc | Probleem | Deze handleiding |
|---|---|---|
Een LocalScript telt munten op met leaderstats.Coins.Value += 1 | De wijziging blijft op één apparaat, en een exploiter heeft zijn eigen apparaat in handen | De server telt de munten op |
clickEvent:FireServer(amount) | De client kiest zelf zijn beloning | Click stuurt geen argumenten mee |
| Geen frequentielimiet op de server | In de Roblox-documentatie staat dat je nooit alleen op een limiet op de client moet vertrouwen | Niet meer dan 15 klikken per venster van een seconde |
SetAsync bij elke klik of upgrade | Vreet de schrijflimiet van de server op | PlayerData 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 simulator | Twee scripts die dezelfde sleutel opslaan, overschrijven elkaar | Schrijft in de tabel van PlayerData |
Lussen while wait(1) do voor passief inkomen | Roblox markeert de globale wait als verouderd, hij is vervangen door task.wait | task.wait (zie Uitbreiden) |
MouseButton1Click op knoppen | Bedoeld voor muisklikken | Activated, 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.
- Druk op Play. Bovenaan het scherm staat 0 coins, op de groene knop Upgrade: 10 en op de oranje Rebirth: 1.0K.
- Druk tien keer op de paarse knop Click!. Elke klik toont een gouden +1, en Coins in de spelerslijst gaat met 1 omhoog.
- 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.
- Druk zonder te klikken op Rebirth. De statusregel zegt "You need 1000 more coins to rebirth." en er verandert niets.
- Wil je de rebirth testen zonder 1.000 keer te klikken, stop dan de test, verander
Coins = 0inCoins = 1000in 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. - Wil je de frequentielimiet zien, zet
MAX_CLICKS_PER_SECONDin 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. - 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.
- 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.
- Verdien met opslaan aan (stap 4) en weer
SAVE_PROGRESS = truewat 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.
- Ga in de Explorer met je muis over StarterPack, voeg een Tool in en noem hem
Dumbbell. Voeg er een Part met de naamHandlein, geef hem de vorm van een halter en vink Anchored uit, zoals in de Tool-stappen van de zwaardhandleiding. - Voeg in de Tool een LocalScript met de naam
LiftClientin en plak de code hieronder. - 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 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_SECONDSremt alleen eerlijke spelers af: een cheater kan Click vanuit zijn eigen code aanroepen. Is tillen de enige manier om te verdienen, verlaagMAX_CLICKS_PER_SECONDin 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 = falsetoe direct na de regel in SimulatorClient dieclickButtonmaakt. - 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.
| Volgorde | Systeem | Handleiding | Waarom nu |
|---|---|---|---|
| 1 | Verdienen, upgraden, rebirth | Deze handleiding | Al het andere vermenigvuldigt deze lus, dus stel eerst de getallen af met de tempotabel. |
| 2 | Opslaan | De DataStore-tutorial, daarna stap 4 | Voortgang die bij opnieuw joinen verdwijnt, is de dood van een simulator. Voeg het toe vóór alles wat spelers kunnen verliezen. |
| 3 | Eieren en pets als vermenigvuldigers | Eieren openen en pets die de speler volgen | Een tweede doel naast munten: iets om te verzamelen dat elke klik meer waard maakt. |
| 4 | Zones achter rebirths | Uitbreiden | Een plek om naartoe te gaan na een rebirth, met betere beloningen die de server controleert. |
| 5 | Leaderboards | De leaderboard-handleiding | Een wereldwijde top 10 op rebirths geeft de lange klim betekenis. |
| 6 | Dagelijkse beloningen en codes | Dagelijkse beloningen en codes | Redenen om morgen en na elke update terug te komen. |
| 7 | Gamepasses | De gamepass-handleiding | 2x 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.
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.
- 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
- Roblox Creator Docs: Securing the client-server boundary (in het Engels). frequentielimiet, voorbeeld van een winkel in de game en ClickDetector-events
- Roblox Creator Docs: Security and cheat mitigation tactics (in het Engels). wat een exploiter op zijn eigen apparaat in handen heeft
- Roblox Creator Docs: Remote events and callbacks (in het Engels). FireServer, de spelerparameter, InvokeServer en OnServerInvoke
- Roblox Creator Docs: Leaderboards (in het Engels). leaderstats en geordende datastores
- Roblox Creator Docs: Data store error codes and limits (in het Engels). schrijflimieten per server voor gewone en geordende datastores
- Roblox Engine API: GuiButton (in het Engels). Activated op computer, telefoon en console
- Roblox Engine API: GuiService (in het Engels). AutoSelectGuiEnabled en het selecteren van GUI-objecten met een gamepad
- Roblox Engine API: IntValue (in het Engels). 64-bits bereik en verlies van precisie boven 2^53
- Roblox Creator Docs: Size modifiers and constraints (in het Engels). UIAspectRatioConstraint en UISizeConstraint
- Roblox Creator Docs: Studio testing modes (in het Engels). Device Simulator en Controller Emulator
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.