Kort fortalt
En simulator i Roblox er én løkke: klikk for å få mynter, bruk dem på oppgraderinger som gir flere, og ta så en rebirth for en permanent multiplikator. Legg prisene i et ModuleScript i ReplicatedStorage. Ett Script i ServerScriptService holder hver spillers Coins, Click Power og Rebirths, teller høyst 15 klikk i sekundet fra RemoteEvent Click og selger oppgraderinger og rebirths via en RemoteFunction etter å ha sjekket prisen. Et LocalScript viser knappene Click, Upgrade og Rebirth. Med tallene fra denne guiden når en spiller som klikker 5 ganger i sekundet, sin første rebirth på omtrent 1.2 minutter, og tempotabellen viser hva du skal endre for å gjøre oppstigningen lengre.
- Et klikk sender ikke noe annet enn selve klikket. Hva det er verdt, regner serveren ut, så en endret klient ikke kan gi seg selv mynter.
- Lagre hele tabellen med en timer og når spilleren går, ikke ved hvert klikk. Roblox gir hver server 60 + 40 × spillere skrivinger til datastore i minuttet.
- Kan du ikke skripte? Den samme løkken kan bygges av et kit fra Creator Store, en plugin eller en AI-agent. Sjekk at serveren bestemmer myntene: alternativene.
- Vil du ha et treningssenter eller en gruve i stedet for en knapp? Et Tool kan kalle den samme remoten Click: versjonen med manual. Legg deretter til systemer etter byggerekkefølgen nedenfor.
På denne siden
Hvordan grunnløkken i en simulator er bygd opp
En simulator er en løkke av tre handlinger. Spilleren gjør noe enkelt om og om igjen for å tjene valuta, bruker den på oppgraderinger som gir den raskere, og når oppgraderingene blir dyre, tar spilleren en rebirth: gir fra seg mynter og oppgraderinger for en bonus som blir for alltid, og stiger igjen, nå raskere. I andre simulatorer løfter man manualer, graver eller samler ting i stedet for å klikke, men løkken under er den samme.
| Handling | Hva den koster | Hva den gir | Hvem som bestemmer |
|---|---|---|---|
| Klikk | Ingenting | Mynter lik Click Power × (Rebirths + 1) | Serveren, som teller høyst 15 klikk i hvert vindu på ett sekund |
| Oppgradering | 10 mynter, deretter 1.5 ganger forrige pris for hvert level | Ett level til av Click Power, opptil level 50 | Serveren, ut fra sin egen kopi av prisene |
| Rebirth | 1 000 mynter, deretter 3 ganger forrige pris for hver rebirth | Mynter tilbake til 0 og Click Power tilbake til level 1, pluss en permanent +1 til multiplikatoren | Serveren |
Hvert tall bor på serveren. Spillerens enhet tegner knappene og spør ("jeg klikket", "jeg vil ha en oppgradering"), og serveren bestemmer hva det koster, og om det går an. Klikker-skript som blir hacket, legger ofte til mynter i et LocalScript eller lar klienten sende hvor mange mynter som skal legges til.
| Del | Hvor den ligger | Hva den gjør |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Priser, grenser og formler for hva et klikk er verdt, hva en oppgradering koster og hva en rebirth koster. Begge sider leser den. |
Script SimulatorService | ServerScriptService | Holder hver spillers tall, håndterer klikk, oppgraderinger og rebirths og fyller ut leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (opprettes av SimulatorService) | RemoteEvent Click og RemoteFunctions BuyUpgrade og Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | Bygger knappene, sender klikk og forespørsler og viser serverens tall. |
ModuleScript PlayerData (valgfritt) | ServerScriptService | Lagrer fremgangen mellom besøk. Den kommer fra tutorialen om DataStore og trengs bare for steg 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
Steg 1: legg priser og formler i en modul
Hvert tall du kan komme til å justere, havner i ett ModuleScript: hva et klikk er verdt, hva hver oppgradering og rebirth koster, og grensen for klikk. Serveren bestemmer ut fra det, og LocalScriptet henter prisene til knappene fra det, så enhver endring er én retting på ett sted.
- Hold musepekeren over ReplicatedStorage i Explorer, klikk på knappen +, og sett inn et ModuleScript.
- Gi det nytt navn til
SimulatorConfig(navn skiller mellom store og små bokstaver), og erstatt innholdet med koden nedenfor.
-- Alle tallene i grunnløkken og formlene som begge sider bruker. Klienten viser bare
-- priser ut fra dem; serveren bestemmer ut fra sin egen kopi.
local SimulatorConfig = {}
SimulatorConfig.UPGRADE_BASE_COST = 10 -- prisen for Click Power level 2
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- hvert level koster 1.5 ganger det forrige
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- mynter til den første rebirthen
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- hver rebirth koster 3 ganger den forrige
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- klikk utover dette på ett sekund ignoreres
-- Mynter per klikk: Click Power-level ganget med 1 + antallet rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
return powerLevel * (rebirths + 1)
end
-- Prisen for neste level av Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end
-- Mynter som trengs for neste rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end
return SimulatorConfig
Spillere kan lese et ModuleScript i ReplicatedStorage, så disse prisene er offentlige. Det er greit: de står jo også på knappene. Klienten og serveren kjører hver sin egen kopi av modulen, så en spiller som endrer tallene på enheten sin, endrer ingenting på serveren.
| Click Power-level | Pris for neste level | Mynter per klikk, uten rebirths | Mynter per klikk, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
Rebirths koster 1 000 mynter, så 3 000, så 9 000, fordi rebirthCost ganger prisen med 3 hver gang. Etter én rebirth er hvert klikk verdt dobbelt så mye, etter to tre ganger så mye, og så videre.
Hvor lang tid en rebirth tar med disse tallene
Formlene bestemmer hvor lenge løkken varer, så det lønner seg å regne ut tallene før spillerne gjør det. Tabellen går ut fra at spilleren tar en rebirth så snart den har råd, og resten av tiden kjøper neste level av Click Power når den har råd, og det koster mindre enn en rebirth. Tiden regnes fra en ny start, så den siste kolonnen er den samlede tiden til 3 rebirths.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1 000 (denne guiden) | 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 |
Uten rebirths kommer Click Power level 5 etter 34 klikk, level 10 etter 122 og level 13 etter 285. Med standardtallene slutter spilleren deretter å oppgradere, fordi level 14 koster 1 297 mynter, mer enn en rebirth til 1 000 mynter, og den første rebirthen kommer etter 362 klikk totalt. Med serverens grense på 15 klikk i sekundet deler du hver tid på 3. Endrer du et hvilket som helst tall i SimulatorConfig, endrer disse tidene seg også, så regn dem ut på nytt.
Justere veksten
De to tallene _GROWTH bestemmer hvor raskt prisene stiger. Ved 1.5 koster hver oppgradering halvannen gang så mye som den forrige, mens hvert level bare legger til én mynt per klikk (før rebirth-multiplikatoren), så hvert nye level tar lengre tid å tjene inn. Det er nettopp den nedbremsingen som gjør en rebirth verdt det. Øk veksten for en lengre oppstigning, senk den for en raskere, og hold REBIRTH_BASE_COST høy nok til at spillerne kjøper noen oppgraderinger før den første rebirthen.
Hvis den første rebirthen skal komme etter noen minutter i stedet for etter omtrent ett, så øk REBIRTH_BASE_COST til 5 000 eller 10 000.
Steg 2: legg til serverskriptet
Dette Scriptet eier hvert tall. Det oppretter remotene, gir hver spiller en mappe leaderstats med Coins og Rebirths og svarer på tre forespørsler. Hold musepekeren over ServerScriptService, sett inn et Script, gi det nytt navn til SimulatorService, og erstatt innholdet med denne koden:
-- Eier hvert tall: klikk gir mynter her, oppgraderinger og rebirths kjøpes her,
-- og leaderstats viser bare resultatet.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- false: alle starter fra null ved hvert besøk. true: innlasting og lagring via modulen PlayerData
-- fra tutorialen om DataStore (legg først til PowerLevel = 1 og Rebirths = 0 i DEFAULTS der).
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 } = {} -- når spillerens nåværende sekundvindu startet
local clickCount: { [Player]: number } = {} -- klikk som er telt med i dette vinduet
-- Kopierer serverens tall dit spillerne ser dem: til leaderstats og ett attributt
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
-- Starter spilleren med de gitte dataene (nye tall eller en lagret tabell)
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
-- Et klikk bærer ingen tall: hva det er verdt, regner serveren ut
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 -- en autoklikker eller et skript som kaller remoten i en løkke
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
-- En rebirth bytter mynter og oppgraderinger mot en permanent multiplikator
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
-- Starttall: nye eller tabellen som modulen PlayerData laster inn og lagrer
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) -- den samme tabellen som PlayerData lagrer, så hver endring blir lagret
end
PlayerData.Loaded:Connect(onLoaded)
for _, player in Players:GetPlayers() do
onLoaded(player) -- alle der data ble lastet inn før dette skriptet startet
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 når fram til spilleren som attributtet PowerLevel på spillerens Player-objekt og ikke som en tredje verdi i leaderstats, så spillerlisten bare viser Coins og Rebirths. Attributter som serveren setter, replikeres til spillerens enhet; en endring som spilleren gjør på enheten sin, blir værende der.
Klikk og grense for hyppighet
Remoten Click sender ingen argumenter. På serveren er den første parameteren i handleren OnServerEvent alltid spilleren som kalte den, så serveren vet hvem som klikket, henter spillerens Click Power-level og Rebirths og legger clickValue til spillerens Coins. Det finnes ingenting i forespørselen som en juksemaker kunne endre.
Roblox' guide til sikkerhet sier at man aldri må stole bare på en grense for hyppighet på klienten, og utbetaling av valuta står blant handlingene som skal begrenses. Serveren teller hver spillers klikk i vinduer på ett sekund: det første klikket åpner et vindu, og når 15 klikk er telt med, ignoreres resten til det har gått ett sekund siden vinduet startet. Et skript som kaller remoten i en løkke, får høyst 15 telte klikk i hvert vindu. For å tillate raskere eller saktere klikking endrer du MAX_CLICKS_PER_SECOND i SimulatorConfig.
Oppgraderinger og rebirths
BuyUpgrade og Rebirth er RemoteFunctions, så knappen kan vente på svaret og vise det. Hver handler henter prisen fra serverens kopi av SimulatorConfig, sjekker spillerens Coins og endrer først deretter noe. Den returnerer true eller false og en melding, for eksempel "You need 5 more coins.", som LocalScriptet viser i statuslinjen.
Mellom sjekken av prisen og endringen venter ingenting og gir ingenting fra seg kjøringen (yield), så to forespørsler fra samme spiller kan ikke begge komme gjennom sjekken før den første har tatt myntene. En rebirth setter Coins til 0, Click Power til level 1 og legger 1 til Rebirths, og klikkformelen gjør det om til multiplikatoren Rebirths + 1.
Bryteren SAVE_PROGRESS
Med SAVE_PROGRESS = false starter hver spiller med 0 mynter ved hvert besøk, og det er det du vil ha mens du bygger spillet. Steg 4 slår den på. Da venter skriptet på at modulen PlayerData laster inn hver spiller, og jobber direkte med tabellen som modulen lagrer, så hver mynt og hver rebirth blir lagret uten ekstra kode.
Steg 3: bygg knappene
Dette LocalScriptet bygger hele skjermen i kode: en mynteteller øverst, en stor Click-knapp i midten, knappene Upgrade og Rebirth nederst og en statuslinje for serverens svar. Selv endrer det aldri et eneste tall.
- Fold ut StarterPlayer i Explorer, hold musepekeren over StarterPlayerScripts, og sett inn et LocalScript med navnet
SimulatorClient. - Erstatt innholdet med koden nedenfor, og trykk på Play.
-- Bygger knappene i simulatoren og viser serverens tall. Selv endrer det dem aldri.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TweenService = game:GetService("TweenService")
type Config = {
MAX_POWER_LEVEL: number,
clickValue: (powerLevel: number, rebirths: number) -> number,
upgradeCost: (powerLevel: number) -> number,
rebirthCost: (rebirths: number) -> number,
}
local Config = require(ReplicatedStorage:WaitForChild("SimulatorConfig")) :: Config
local remotes = ReplicatedStorage:WaitForChild("SimulatorRemotes")
local clickEvent = remotes:WaitForChild("Click") :: RemoteEvent
local buyUpgrade = remotes:WaitForChild("BuyUpgrade") :: RemoteFunction
local rebirthRemote = remotes:WaitForChild("Rebirth") :: RemoteFunction
local player = Players.LocalPlayer
local leaderstats = player:WaitForChild("leaderstats")
local coins = leaderstats:WaitForChild("Coins") :: IntValue
local rebirths = leaderstats:WaitForChild("Rebirths") :: IntValue
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)
-- 1234 -> "1.2K", 5600000 -> "5.6M"
local UNITS = {
{ size = 1e12, suffix = "T" },
{ size = 1e9, suffix = "B" },
{ size = 1e6, suffix = "M" },
{ size = 1e3, suffix = "K" },
}
local function short(n: number): string
for _, unit in UNITS do
if n >= unit.size then
return string.format("%.1f%s", math.floor(n / unit.size * 10) / 10, unit.suffix)
end
end
return tostring(n)
end
local function newButton(parent: Instance, text: string, position: UDim2, size: UDim2, color: Color3): TextButton
local button = Instance.new("TextButton")
button.AnchorPoint = Vector2.new(0.5, 0.5)
button.Position = position
button.Size = size
button.BackgroundColor3 = color
button.TextColor3 = Color3.new(1, 1, 1)
button.FontFace = BOLD
button.TextScaled = true
button.Text = text
button.Parent = parent
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 12)
corner.Parent = button
return button
end
local gui = Instance.new("ScreenGui")
gui.Name = "SimulatorGui"
gui.ResetOnSpawn = false
local coinsLabel = Instance.new("TextLabel")
coinsLabel.AnchorPoint = Vector2.new(0.5, 0)
coinsLabel.Position = UDim2.new(0.5, 0, 0, 12)
coinsLabel.Size = UDim2.fromOffset(320, 48)
coinsLabel.BackgroundTransparency = 1
coinsLabel.TextColor3 = Color3.fromRGB(255, 214, 90)
coinsLabel.FontFace = BOLD
coinsLabel.TextScaled = true
coinsLabel.Parent = gui
local clickButton = newButton(gui, "Click!", UDim2.new(0.5, 0, 0.5, -30), UDim2.fromScale(0.38, 0.38), Color3.fromRGB(124, 77, 255))
-- Click-knappen forblir kvadratisk, tilpasset skjermen og ikke større enn 200 ganger 200,
-- så den på en telefon får plass mellom myntetelleren og knappene nederst
local square = Instance.new("UIAspectRatioConstraint")
square.Parent = clickButton
local maxSize = Instance.new("UISizeConstraint")
maxSize.MaxSize = Vector2.new(200, 200)
maxSize.Parent = clickButton
local upgradeButton = newButton(gui, "", UDim2.new(0.5, -110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(40, 150, 90))
local rebirthButton = newButton(gui, "", UDim2.new(0.5, 110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(200, 90, 40))
local status = Instance.new("TextLabel")
status.AnchorPoint = Vector2.new(0.5, 1)
status.Position = UDim2.new(0.5, 0, 1, -96)
status.Size = UDim2.fromOffset(480, 28)
status.BackgroundTransparency = 1
status.TextColor3 = Color3.new(1, 1, 1)
status.FontFace = BOLD
status.TextSize = 20
status.Text = ""
status.Parent = gui
gui.Parent = player:WaitForChild("PlayerGui")
local function powerLevel(): number
local level = player:GetAttribute("PowerLevel")
return if type(level) == "number" then level else 1
end
local function update()
coinsLabel.Text = `{short(coins.Value)} coins`
local level = powerLevel()
upgradeButton.Text = if level >= Config.MAX_POWER_LEVEL
then "Click Power maxed"
else `Upgrade: {short(Config.upgradeCost(level))}`
rebirthButton.Text = `Rebirth: {short(Config.rebirthCost(rebirths.Value))}`
end
coins.Changed:Connect(update)
rebirths.Changed:Connect(update)
player:GetAttributeChangedSignal("PowerLevel"):Connect(update)
update()
-- "+N" som spretter opp over knappen. Tallet er bare en gjetning for utseendets skyld;
-- hva et klikk faktisk er verdt, bestemmer serveren.
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)
Knappene bruker Activated, som Roblox utløser ved et venstreklikk med musen på en datamaskin, ved et trykk på en telefon og ved et trykk på A (eller krysset) på en gamepad i UI-navigasjonsmodus.
På en gamepad trykker A bare på den valgte knappen. Når GuiService.AutoSelectGuiEnabled er slått på, velger knappen Select på gamepaden knappene dine på skjermen; deretter kan spillerne bytte mellom dem og trykke på A. Hvis du vil at en gamepad-knapp skal klikke med en gang, så bind den med ContextActionService, og kall den samme remoten Click fra den.
Fire detaljer i skriptet:
- Click-knappen skalerer med skjermen. Størrelsen er en andel av skjermen,
UIAspectRatioConstraintholder den kvadratisk, ogUISizeConstraintbegrenser den til 200 ganger 200 piksler. På en dataskjerm er den 200 piksler bred; på en telefon blir den mindre og passer mellom myntetelleren og knappene nederst. Hvis du flytter elementer, så hold den unna dem: Rebirth har ingen bekreftelse, så et utilsiktet trykk kan nullstille spillerens mynter og oppgraderinger. - "+N" som spretter opp, er bare for utseendets skyld. Det bruker klientens kopi av formelen. Hvis serveren ignorerer et klikk på grunn av grensen for hyppighet, dukker "+N" opp likevel, men myntene endrer seg ikke.
short()gjør store tall lesbare. 1 234 vises som 1.2K, og 5 600 000 som 5.6M. Funksjonen runder ned, så telleren aldri viser mer enn du har. For tall over T (billioner) legger du til oppføringer iUNITS.- Skjermen oppdateres via events. Den lytter etter verdiene Coins og Rebirths og attributtet PowerLevel, så prisene på knappene er riktige uansett hvordan tallene endrer seg.
ScreenGuien har ResetOnSpawn satt til false, så den blir værende når karakteren gjenoppstår. Her er det viktig: et LocalScript i StarterPlayerScripts kopieres til spilleren én gang, ved inngang, så det ville ikke bygge skjermen på nytt.
Steg 4: lagre fremgangen med PlayerData
Foreløpig nullstilles alt når spilleren går. I stedet for et ekstra lagringsskript kobler simulatoren seg til modulen PlayerData fra tutorialen om DataStore. Den modulen prøver allerede mislykkede forespørsler på nytt, lagrer automatisk hvert 180. sekund, lagrer når spilleren går og når serveren stenger, og lagrer aldri en spiller hvis data ikke ble lastet inn.
- Følg steg 1 i tutorialen om DataStore for å legge til ModuleScriptet
PlayerDatai ServerScriptService. For å teste lagring i Studio må du slå på Studios tilgang til API-tjenester i en testkopi av spillet, slik første del av den forklarer. SimulatorService henter selv modulen med require, så skriptetMainfra tutorialen trengs ikke her. - Legg til
PowerLevel = 1,ogRebirths = 0,i tabellenDEFAULTSi PlayerData, ved siden avCoins = 0,. - Legg til
PowerLevel: number,ogRebirths: number,i typenDatai samme modul, så den strenge typesjekken kjenner de nye feltene. - Erstatt
local SAVE_PROGRESS = falsemedlocal SAVE_PROGRESS = truei SimulatorService.
Spillere som ble lagret før du la til feltene, får dem automatisk: funksjonen migrate i PlayerData fyller ut alle felt fra DEFAULTS som mangler i den lagrede tabellen, så de starter med Click Power level 1 og 0 rebirths og beholder sine Coins. Hvis du hopper over punkt 2, skriver SimulatorService ut en advarsel med feltene som må legges til, og starter ikke spilleren.
Hvorfor simulatoren skriver i tabellen til PlayerData
Når lagring er slått på, kopierer SimulatorService ikke tallene noe sted. PlayerData.Get(player) returnerer den levende tabellen som modulen lagrer, og simulatoren endrer Coins, PowerLevel og Rebirths i akkurat den tabellen. Hvert tall har én kopi, og ett skript skriver til datastore. To skript som lagrer den samme nøkkelen, overskriver hverandre, og det ene kan lagre gamle tall oppå tallene til det andre.
Ikke lag leaderstats i handleren Loaded i tillegg, slik tutorialen om DataStore anbefaler for andre spill: SimulatorService lager allerede Coins og Rebirths ut fra den innlastede tabellen. Hvis et leaderboard-skript allerede lager leaderstats, så slett det.
Hvorfor man ikke skal lagre ved hvert klikk
Roblox gir hver server 60 + 40 × spillere skrivinger til en vanlig datastore i minuttet (resten står i tabellen over grenser i tutorialen om DataStore). Å lagre ved hvert klikk ved 15 klikk i sekundet er 900 skrivinger i minuttet for én spiller, langt mer enn de 100 en server med én spiller får. Å lagre hele tabellen hvert 180. sekund, når spilleren går og når serveren stenger, koster bare noen få skrivinger per spiller, og ved et krasj går høyst fremgangen siden forrige automatiske lagring tapt.
Hvis innlastingen mislyktes, lar modulen spilleren spille med nye tall, men lagrer dem aldri, så en dårlig innlasting ikke kan overskrive ekte fremgang. Tutorialen forklarer hvordan modulen håndterer det.
Hvorfor serveren bestemmer hvert tall
Exploitere styrer sin egen enhet. Roblox' guide til sikkerhet sier at de kan endre hva som helst i sin lokale kopi av spillet og kalle enhver RemoteEvent eller RemoteFunction så mange ganger de vil, med hvilke argumenter som helst. Økonomien i en simulator er nøyaktig så sikker som serverskriptet.
| Exploiteren prøver å | Hvis klienten bestemte | Hva SimulatorService gjør |
|---|---|---|
| Kalle Click i en løkke så raskt som mulig | Uendelig med mynter | Teller høyst 15 klikk i hvert sekundvindu og ignorerer resten. |
| Sende et antall mynter med klikket | Han velger selv belønningen sin | Ignorerer alle argumenter. Verdien av et klikk kommer fra serverens tall. |
| Kjøpe en oppgradering eller rebirth uten de nødvendige myntene | Gratis oppgraderinger | Sammenligner prisen med Coins på serveren og svarer "You need N more coins." |
| Endre Coins i leaderstats på skjermen sin | Bruke mynter han ikke har | Leser aldri leaderstats. Den skriver bare dit fra tabellen sin. |
| Sette attributtet PowerLevel på sin Player | Et sterkere klikk | Leser aldri det attributtet, og endringen blir værende på spillerens enhet. |
| Kalle Rebirth to ganger i samme øyeblikk | To rebirths til prisen for én | Sjekker prisen på nytt ved hvert kall, og mellom sjekken og endringen gir ingenting fra seg kjøringen. |
| Endre prisene i sin kopi av SimulatorConfig | Billigere oppgraderinger | Bruker sin egen kopi av modulen. |
Regelen gjelder for hver remote i simulatoren: send det spilleren vil gjøre, ikke hva det koster. Guiden til RemoteEvent går gjennom sjekk av argumentene til remotes mer i detalj.
Hva du bør unngå i kopierte klikker-skript
| Grep | Problem | Denne guiden |
|---|---|---|
Et LocalScript legger til mynter med leaderstats.Coins.Value += 1 | Endringen blir værende på én enhet, og sin egen enhet styrer exploiteren | Serveren legger til mynter |
clickEvent:FireServer(amount) | Klienten velger selv belønningen sin | Click sender ingen argumenter |
| Ingen grense for hyppighet på serveren | Roblox-dokumentasjonen sier at man aldri må stole bare på en grense på klienten | Høyst 15 klikk i hvert sekundvindu |
SetAsync ved hvert klikk eller hver oppgradering | Spiser opp serverens skrivegrense | PlayerData lagrer hvert 180. sekund, når spilleren går og ved stenging. Lagre bare med en gang med PlayerData.SaveNow etter noe som ikke må gå tapt, for eksempel kjøp for Robux. |
| Et ekstra datastore-skript bare for simulatoren | To skript som lagrer den samme nøkkelen, overskriver hverandre | Skriver i tabellen til PlayerData |
Løkker med while wait(1) do for passiv inntekt | Roblox merker den globale wait som utdatert, den erstattes av task.wait | task.wait (se Hvordan utvide) |
MouseButton1Click på knapper | Beskrevet for museklikk | Activated, for mus, trykk og gamepad |
Steg 5: test det
Gå gjennom punkt 1 til 8 med SAVE_PROGRESS = false i SimulatorService, så hver playtest starter med nye tall. Hvis du allerede har slått på lagring i steg 4, så sett den til false inntil videre, og sett den tilbake til true for punkt 9.
- Trykk på Play. Øverst på skjermen står det 0 coins, på den grønne knappen Upgrade: 10 og på den oransje Rebirth: 1.0K.
- Trykk på den lilla knappen Click! ti ganger. Hvert klikk viser en gyllen +1, og Coins i spillerlisten øker med 1.
- Trykk på Upgrade. Myntene går tilbake til 0, statuslinjen blir grønn med teksten "Click Power is now level 2.", og knappen sier nå Upgrade: 15. Fra nå av gir hvert klikk 2 mynter.
- Trykk på Rebirth uten å klikke. Statuslinjen skriver "You need 1000 more coins to rebirth.", og ingenting endrer seg.
- For å teste en rebirth uten 1 000 klikk stopper du testen, endrer
Coins = 0tilCoins = 1000i linjen nær slutten av SimulatorService som starter nye spillere, og trykker på Play. Trykk på Rebirth: Coins blir 0, Rebirths i spillerlisten blir 1, statuslinjen skriver "Rebirth 1! Every click is now worth x2.", og knappen sier nå Rebirth: 3.0K. Hvert klikk gir nå 2 mynter på Click Power level 1. Sett deretter linjen tilbake til 0. - For å se grensen for hyppighet setter du
MAX_CLICKS_PER_SECONDi SimulatorConfig til 2 og klikker raskt. "+N" fortsetter å dukke opp, men Coins øker høyst med verdien av 2 klikk i sekundet. Sett den tilbake til 15. - Velg en telefon i Device Simulator i Studio (det er en Studio-beta; den gamle Device Emulator fungerer også), og trykk på Play. Sjekk at Click-knappen ikke går inn over myntetelleren eller knappene Upgrade og Rebirth, og at statuslinjen er synlig og ikke dekkes av en knapp når du trykker på Upgrade.
- Koble til en gamepad, eller åpne Controller Emulator i Studio (Controller i fanen Emulation) under en playtest, trykk på Select, og sjekk at du kan nå alle tre knappene og trykke på dem med A.
- Med lagring slått på (steg 4) og igjen
SAVE_PROGRESS = truetjener du noen mynter, trykker på Stop og så Play igjen. Coins, Click Power-level og Rebirths kommer tilbake.
Lag en treningssimulator eller en gruvesimulator
Mange simulatorer erstatter knappen med en handling i verden: løft en manual, sving en hakke, sving et sverd i luften. Under er det det samme klikket. Et Tool kan kalle den samme remoten Click, så SimulatorService, prisene og grensen for hyppighet forblir som de er.
- Hold musepekeren over StarterPack i Explorer, sett inn et Tool, og kall det
Dumbbell. Sett inn en Part med navnetHandlei det, gi den form som en manual, og fjern haken i Anchored, som i stegene med Tool i guiden til sverd. - Sett inn et LocalScript med navnet
LiftClienti toolet, og lim inn koden nedenfor. - Trykk på Play, ta manualen, og klikk. Myntene øker med din Click Power for hvert løft, akkurat som med knappen.
-- LocalScript inne i toolet Dumbbell, med navnet LiftClient.
-- Hvert løft er et klikk: det kaller den samme remoten Click som knappen, og serveren
-- bestemmer hva det er verdt, og hvor mange løft som telles med.
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 -- tid mellom løft på denne enheten; serveren har sin egen grense
local LIFT_ANIMATION_ID = "" -- valgfritt: "rbxassetid://" etterfulgt av id-en til animasjonen din
local player = Players.LocalPlayer
local lastLift = 0
local liftTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil
-- Last inn løfteanimasjonen én gang per karakter via Animatoren som Roblox legger i Humanoid
local function loadLift()
local character = player.Character
if LIFT_ANIMATION_ID == "" or not character or character == trackCharacter then
return
end
local humanoid = character:FindFirstChildOfClass("Humanoid")
local animator = humanoid and humanoid:FindFirstChildOfClass("Animator")
if animator then
local animation = Instance.new("Animation")
animation.AnimationId = LIFT_ANIMATION_ID
liftTrack = animator:LoadAnimation(animation)
trackCharacter = character
end
end
tool.Equipped:Connect(loadLift)
tool.Activated:Connect(function()
local now = os.clock()
if now - lastLift < LIFT_SECONDS then
return
end
lastLift = now
if liftTrack then
liftTrack:Play()
end
clickEvent:FireServer() -- uten argumenter: belønningen regner serveren ut
end)
For en løfteanimasjon lager du den i Animation Editor med prioriteten Action, publiserer den og setter ID-en inn i LIFT_ANIMATION_ID. Stegene med animasjon fra guiden til sverd fungerer på samme måte.
- Tilpass serverens grense til handlingen.
LIFT_SECONDSbremser bare ærlige spillere: en juksemaker kan kalle Click fra sin egen kode. Hvis løftet er den eneste måten å tjene på, så senkMAX_CLICKS_PER_SECONDi SimulatorConfig til det faktiske tempoet, for eksempel til 2 for ett løft hvert 0.5 sekund, så et skript ikke kan tjene mer enn en spiller. Regn deretter tempotabellen ut på nytt: hver tid i den er beregnet ut fra 5 klikk i sekundet. - Behold eller skjul knappen. Click-knappen fungerer fortsatt ved siden av toolet. For å skjule den legger du til
clickButton.Visible = falserett etter linjen i SimulatorClient som oppretterclickButton. - Inntekt bare på riktig sted. For å betale bare i treningssenteret eller i gruven sjekker du på serveren hvor karakteren er før et klikk telles med, for eksempel ut fra avstanden til en part i den sonen. En sjekk i LiftClient ville ikke stoppe noen.
Hva du gjør etterpå: byggerekkefølgen for en simulator
En simulator er en stabel med systemer oppå denne løkken. Bygg dem i denne rekkefølgen, så hvert system har noe å gange, og kjør en playtest etter hvert. Her er rekkefølgen vi anbefaler, med en guide til hvert steg.
| Rekkefølge | System | Guide | Hvorfor akkurat nå |
|---|---|---|---|
| 1 | Inntekt, oppgradering, rebirth | Denne guiden | Alt annet ganger denne løkken, så juster først tallene etter tempotabellen. |
| 2 | Lagring | Tutorialen om DataStore, deretter steg 4 | Fremgang som nullstilles når man kommer inn igjen, dreper en simulator. Legg det til før alt spillerne kan miste. |
| 3 | Egg og pets som multiplikatorer | Åpning av egg og pets som følger spilleren | Et annet mål ved siden av myntene: noe å samle på som gjør hvert klikk mer verdt. |
| 4 | Soner bak rebirths | Hvordan utvide | Hvor man kan gå etter en rebirth, med bedre belønninger som serveren sjekker. |
| 5 | Leaderboards | Guiden til leaderboards | En global topp 10 over rebirths gir den lange oppstigningen mening. |
| 6 | Daglige belønninger og koder | Daglige belønninger og koder | Grunner til å komme tilbake i morgen og etter hver oppdatering. |
| 7 | Gamepasses | Guiden til gamepasses | 2x mynter, autoklikk eller en ekstra plass til et pet, med sjekk på serveren. Selg dem når den gratis løkken allerede er morsom. |
For skjermene inneholder de gratis UI-kitene for Roblox skjermer i simulatorstil sammen med skriptene som får dem til å fungere.
Hvordan lage en simulator uten å skrive skript
En simulator trenger fortsatt skript: noen må legge til mynter, sjekke priser og lagre. Du trenger ikke å skrive dem selv:
- Et simulator-kit fra Creator Store. Les skriptene før publisering, og sjekk at myntene bare endres i et Script på serveren, ikke i et LocalScript.
- En plugin som genererer simulatorer. Den samme sjekken for alt den lager.
- En AI-agent i Studio, for eksempel RoCode, som kan bygge de samme tre skriptene i placen du har åpen.
- Build i Roblox' mobilapp. Ifølge Roblox-dokumentasjonen lager den enklere 2D- og 2.5D-spill ut fra en beskrivelse, for eksempel klikkere, og rulles gradvis ut etter region.
Uansett hva du velger, så kjør sjekkene fra steg 5 og sjekkene for exploits fra delen Hvorfor serveren bestemmer hvert tall på resultatet.
Hvordan utvide: pets, soner, autoklikk og leaderboards
Pets som multiplikatorer
En vanlig variant: hvert pet er en multiplikator. Lagre listen over spillerens pet-id-er i spillerens lagrede tabell, og la serveren gange clickValue med bonusen fra hvert pet spilleren har på. Åpne egg på serveren: klienten ber om å åpne et egg, serveren sjekker og tar prisen og velger deretter et pet med et vektet tilfeldig trekk. La aldri klienten trekke for et egg eller si hvilket pet som kom ut. Guiden til inventar viser hvordan du lagrer, oppbevarer og viser spillerens ting, og pets fungerer på samme måte. Guiden til åpning av egg bygger trekket på serveren, og guiden til pets får pets til å fly ved siden av eieren.
Soner som låses opp med rebirths
En sone er en del av kartet med bedre belønninger bak en barriere. Lås belønningen, ikke bare døren: alt som betaler inne i sonen, må sjekke spillerens Rebirths i serverens tabell før det betaler. En dør som et LocalScript åpner for de riktige spillerne, er fin for utseendet, men exploitere kan endre parts og flytte karakteren sin på sin egen enhet.
Autoklikk som gamepass
En autoklikker som selges som gamepass, må kjøre på serveren. Flytt innholdet i Click-handleren inn i en funksjon, for eksempel addClick(player), koble remoten til den, og kall den for eierne av passet fra en serverløkke med task.wait(0.5) og ikke med den utdaterte wait. Da teller autoklikk med i den samme grensen per sekund som vanlige klikk. Sjekk eierskap på serveren med MarketplaceService:UserOwnsGamePassAsync, slik guiden til gamepasses gjør for sine bonuser. Et pass med 2x mynter fungerer på samme måte: gang clickValue på serveren for eierne. Før du setter en pris, viser den gratis Robux-skattekalkulatoren hvor mye hvert salg gir deg etter Roblox' andel, og DevEx-kalkulatoren viser hva de Robuxene er verdt i amerikanske dollar.
En global topp 10 over rebirths
leaderstats sammenligner bare spillere på én server. For å rangere alle spilleres Rebirths skriver du dem i en sortert datastore (ordered data store) og leser de øverste oppføringene tilbake, som i steg 4 i guiden til leaderboards. Sorterte datastores tillater færre skrivinger enn vanlige, 30 + 5 × spillere i minuttet per server, så skriv når spilleren går og med en timer.
Veldig store tall
Tall i Luau er doubles, de holder omtrent 15 signifikante sifre. IntValue holder heltall opptil omtrent 9.2 trillioner, men Roblox advarer om at verdier over 2^53 (omtrent 9 billiarder) mister presisjon i skript. Med disse innstillingene passerer rebirth-prisen den grensen ved rebirth nummer 29. Hvis spillet ditt går lenger, så bytt verdiene i leaderstats til NumberValue (erstatt IntValue i begge skriptene), som holder langt større tall med den samme presisjonen på omtrent 15 sifre, og legg til suffikser i short().
Hva et simulatorspill bygger på
En simulator er et spill med tall. Klikk, oppgradering og rebirth ovenfor er hele løkken; om spillerne blir, avgjøres av hvordan de tallene vokser. Med noen minutters mellomrom skal spilleren ha råd til noe som gjør de neste minuttene raskere, og hver økt skal slutte nær et mål man har lyst til å komme tilbake for.
- Vekst som varer lenge. Prisene på oppgraderinger stiger raskere enn inntekten, så hvert steg tar litt lengre tid. En rebirth nullstiller myntene for en permanent multiplikator, og den gamle sonen blir rask, mens oppstigningen føles ny.
- Noe å samle på. Soner som skal låses opp, pets fra egg som ganger inntekten, og tools som kan oppgraderes, gir spillerne en liste med mål utover ett tall.
- Store tall som forblir lesbare. Vis 1.5M og ikke 1500000, og lagre tallene slik at serveren kan sammenligne dem, også når de blir store.
Monetisering som passer en simulator
Vanlige passes ganger mynter, gir en ekstra plass til et pet, åpner flere egg om gangen eller slår på autoklikk. Selg dem som gamepasses, og sjekk dem på serveren. Myntpakker er developer products. Hvis egg eller noe annet med et tilfeldig resultat kan kjøpes for Robux eller for en valuta kjøpt for Robux, krever Roblox at sannsynlighetene vises før kjøpet: les paid random items (på engelsk) før du bygger butikken.
Hva som får spillerne tilbake
Lagret fremgang, en ny sone eller et sett med pets i oppdateringer, daglige belønninger, koder som annonseres sammen med oppdateringer, og et leaderboard over rebirths. Andre sjangre, hver med sin egen løkke, sine systemer og sin byggeplan: spillsjangre i Roblox.
Vanlige feil og løsninger
Åpne vinduet Output (menyen Window og deretter Output) før du trykker på Play. De fleste problemer skriver der ut en advarsel eller feil med navnet på skriptet og linjen.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("SimulatorRemotes")'
LocalScriptet venter på remotene som SimulatorService oppretter ved start. Sjekk at SimulatorService er et Script og ikke et LocalScript, at det ligger i ServerScriptService, og at det ikke er noen feil fra det i Output. Den samme advarselen for SimulatorConfig betyr at modulen ikke ligger i ReplicatedStorage eller har et annet navn.
Knappene dukker aldri opp
LocalScriptet venter på dine leaderstats før det bygger skjermen. Hvis Output skriver Infinite yield possible på leaderstats, har SimulatorService ennå ikke startet deg. Med SAVE_PROGRESS = true venter det på PlayerData, så sjekk at PlayerData ligger i ServerScriptService og lastes inn uten feil.
Output skriver "SimulatorService: add PowerLevel = 1 and Rebirths = 0 to DEFAULTS in the PlayerData module"
Lagring er slått på, men modulen PlayerData har ennå ikke de nye feltene. Legg dem til i DEFAULTS, som i steg 4, og trykk på Play igjen.
"+1" spretter opp, men myntene øker ikke
Serveren teller ikke klikkene. Enten er det en feil i SimulatorService (se etter rød tekst fra det i Output), eller klikkene kommer raskere enn MAX_CLICKS_PER_SECOND tillater. Hvis spillerne treffer grensen ved vanlig spilling, så øk den i SimulatorConfig.
Statuslinjen skriver "No answer from the server. Try again."
Kallet til BuyUpgrade eller Rebirth krasjet i stedet for å returnere et svar. Den vanlige årsaken er en feil inne i SimulatorService mens forespørselen ble behandlet, så se etter en rød feil fra det i Output: den nevner linjen.
Myntetelleren på skjermen og spillerlisten viser forskjellige tall
Et annet skript lager også en mappe leaderstats, så hver spiller har to, og LocalScriptet kan lese den andre. Slett det overflødige skriptet: SimulatorService lager selv Coins og Rebirths.
Myntene nullstilles hver gang jeg kommer inn igjen
Lagring er slått av. Følg steg 4. Hvis den er slått på og myntene fortsatt nullstilles i Studio, så sjekk at Studios tilgang til API-tjenester er slått på i testkopien, slik tutorialen om DataStore forklarer.
Lag det med RoCode
Hvis du ikke har lyst til å lime det inn for hånd, kan RoCode bygge det i placen du har åpen. Det er en uavhengig AI-agent for kode, ikke fra Roblox: du beskriver systemet i webchatten, og pluginen for Roblox Studio oppretter skript i Explorer, så du ikke trenger å kopiere kode fra chatvinduet.
Lag en klikker-simulator: en stor Click-knapp som gir mynter lik mitt Click Power-level ganget med (rebirths + 1), en Upgrade-knapp som koster 10 mynter og blir 1.5 ganger dyrere for hvert level, og en Rebirth-knapp til 1 000 mynter som nullstiller mynter og oppgraderinger. Hold tallene på serveren, og begrens klikk til 15 i sekundet. Jeg har allerede en PlayerData-modul.
- Kan først lese PlayerData-modulen din og ethvert leaderstats-skript med Search Scripts og Read Script for å legge til felt i dataene du allerede har, i stedet for å skrive et ekstra lagringsskript
- Kan lage et utkast til skjermen med HUD-oppsettet i Build UI (med plugin 3.9 eller nyere, i simulatorstil) eller bygge knappene i et LocalScript, og skriver ModuleScriptet, server-Scriptet og LocalScriptet med Create Script
- Er instruert om å sjekke kompileringen av hvert skript den skriver, med Check Script, som kompilerer det i Studio uten å kjøre det
- Setter et angrepunkt før og etter hver runde med endringer, så Ctrl+Z ruller tilbake én runde om gangen
RoCode kan ikke opprette gamepasses og developer products eller laste opp meshes og ikoner for pets: det gjøres i Creator Hub og Studio. Med plugin 3.9.11 eller nyere kan RoCode kjøre en playtest av spillet ditt i Studio og styre en testkarakter for å sjekke at alt fungerer, og med plugin 3.9.15 eller nyere kan testkarakteren trykke på knapper på skjermen, for eksempel trykke på Click og sjekke at Coins økte. Den bestemmer selv når den kjører en playtest, opptil 2 per bygging pluss 1 for å sjekke rettingen sin, og sjekker bare det den har valgt, så sjekk løkken selv. En hel simulator er flere prompter, ett system om gangen: hvordan du bygger med RoCode ett system per prompt. Hvordan RoCode kobler seg til Studio.
Ofte stilte spørsmål
Hvordan lage en simulator i Roblox uten skript?
En fungerende simulator trenger skript: noen må legge til mynter, sjekke priser og lagre fremgangen. Du kan lime inn de tre skriptene fra denne guiden som de er og bare endre tallene i SimulatorConfig, eller la et kit fra Creator Store, en plugin eller en AI-agent lage dem og sjekke at serveren bestemmer myntene. Alternativene.
Hvordan fungerer et rebirth-system?
En rebirth bytter myntene og oppgraderingene dine mot en permanent bonus. I denne guiden koster den første rebirthen 1 000 mynter; den setter Coins til 0, Click Power til level 1 og legger 1 til Rebirths, og deretter ganges hvert klikk med Rebirths + 1. Hver rebirth koster tre ganger så mye som den forrige.
Hvordan lage en styrke- eller treningssimulator?
Gi spillerne et Tool, for eksempel en manual, der LocalScriptet kaller den samme remoten Click ved Tool.Activated. Serveren regner ut belønningen akkurat som for et klikk på knappen. Senk serverens grense for klikk til tempoet for løft, så et skript ikke kan tjene mer enn en spiller. Skriptet står i delen versjonen med manual.
Hvilke systemer bør en simulator ha?
Først løkken med inntekt, oppgraderinger og rebirths, så lagring, så pets eller en annen samling som ganger inntekten, soner bak rebirths, leaderboards, daglige belønninger og koder, og helt til slutt gamepasses. Byggerekkefølgen har en guide til hvert.
Hvor lang tid bør en rebirth ta?
Lenge nok til at spillerne først kjøper noen oppgraderinger, og kort nok til at de når én i den første økten. Med tallene i denne guiden kommer den første rebirthen etter omtrent 1.2 minutter ved 5 klikk i sekundet; hvis du øker REBIRTH_BASE_COST til 10 000, blir det omtrent 8 minutter. Flere innstillinger i tempotabellen.
Hvordan beskytte seg mot autoklikkere?
Serveren teller høyst 15 klikk per spiller i hvert sekundvindu og ignorerer resten. Under den grensen ser et skript ut som en rask spiller, så det er nettopp grensen som beskytter økonomien. Du kan også selge autoklikk som et gamepass som kjører på serveren.
Hvorfor nullstilles myntene når man kommer inn igjen?
Ingenting lagrer dem ennå. Legg til modulen PlayerData fra tutorialen om DataStore, legg til PowerLevel og Rebirths i DEFAULTS, og sett SAVE_PROGRESS = true i SimulatorService, som i steg 4.
Hvordan legge til pets i en simulator?
Gjør hvert pet til en multiplikator som serveren bruker på klikk. Åpne egg på serveren med et vektet tilfeldig valg, lagre spillerens pet-id-er sammen med resten av dataene til spilleren, og vis dem i en inventar-GUI, som i guiden til inventar.
Hva er best: å klikke på en part eller på en knapp?
Begge fungerer. En knapp på skjermen er praktisk på telefoner, og en part med ClickDetector passer til et spill der alt skjer i verden. Ifølge Roblox-dokumentasjonen sjekker serveren ikke ClickDetector-events i det hele tatt, så begrens hyppigheten av de klikkene på serveren på samme måte.
Kilder og videre lesing
- Roblox Creator Docs: Securing the client-server boundary (på engelsk). grense for hyppighet, eksempelet med en butikk i spillet og ClickDetector-events
- Roblox Creator Docs: Security and cheat mitigation tactics (på engelsk). hva en exploiter styrer på enheten sin
- Roblox Creator Docs: Remote events and callbacks (på engelsk). FireServer, spillerparameteren, InvokeServer og OnServerInvoke
- Roblox Creator Docs: Leaderboards (på engelsk). leaderstats og sorterte datastores
- Roblox Creator Docs: Data store error codes and limits (på engelsk). skrivegrenser per server for vanlige og sorterte datastores
- Roblox Engine API: GuiButton (på engelsk). Activated på datamaskin, telefon og konsoll
- Roblox Engine API: GuiService (på engelsk). AutoSelectGuiEnabled og valg av GUI-objekter med gamepad
- Roblox Engine API: IntValue (på engelsk). 64-biters-intervallet og tap av presisjon over 2^53
- Roblox Creator Docs: Size modifiers and constraints (på engelsk). UIAspectRatioConstraint og UISizeConstraint
- Roblox Creator Docs: Studio testing modes (på engelsk). Device Simulator og Controller Emulator
Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.