Tutorial · Spilsystemer

Sådan laver du en simulator i Roblox

Næsten alle simulatorer kører på den samme løkke: du gør noget enkelt og får valuta, bruger den på opgraderinger, der giver den hurtigere, og laver så en rebirth for at starte forfra med en permanent multiplikator. I denne guide bygger vi den løkke som en klikker af tre scripts, hvor serveren afgør hvert tal, og gemmer fremskridtet med modulet PlayerData fra tutorialen om DataStore. Hvis du aldrig har lavet et spil i Studio før, så lav først en kort bane med mønter.

Opdateret 20. november 202625 min. læsningSkrevet af

Kort fortalt

En simulator i Roblox er én løkke: klik for at få mønter, brug dem på opgraderinger, der giver flere, og lav så en rebirth for en permanent multiplikator. Gem priserne i et ModuleScript i ReplicatedStorage. Ét Script i ServerScriptService holder hver spillers Coins, Click Power og Rebirths, tæller højst 15 klik i sekundet fra RemoteEvent Click og sælger opgraderinger og rebirths via en RemoteFunction efter at have tjekket prisen. Et LocalScript viser knapperne Click, Upgrade og Rebirth. Med tallene fra denne guide når en spiller, der klikker 5 gange i sekundet, sin første rebirth på cirka 1.2 minutter, og tempotabellen viser, hvad du skal ændre for at gøre opstigningen længere.

  • Et klik sender intet andet end selve klikket. Hvad det er værd, regner serveren ud, så en ændret klient ikke kan give sig selv mønter.
  • Gem hele tabellen med en timer og når spilleren går, ikke ved hvert klik. Roblox tillader hver server 60 + 40 × spillere skrivninger til datastore i minuttet.
  • Kan du ikke scripte? Den samme løkke kan bygges af et kit fra Creator Store, et plugin eller en AI-agent. Tjek, at serveren afgør mønterne: mulighederne.
  • Vil du have et træningscenter eller en mine i stedet for en knap? Et Tool kan kalde den samme remote Click: versionen med håndvægt. Tilføj derefter systemer efter byggerækkefølgen nedenfor.
På denne side
  1. Sådan virker det
  2. 1. Indstillingsmodul
  3. 2. Server-script
  4. 3. Knapper
  5. 4. Gemning
  6. Hvorfor serveren afgør
  7. 5. Test
  8. Version med håndvægt
  9. Byggerækkefølge
  10. Uden scripting
  11. Sådan udvider du
  12. Genren
  13. Common errors
  14. Med RoCode
  15. Ofte stillede spørgsmål
  16. Kilder og videre læsning

Sådan er en simulators grundløkke bygget op

IllustrationSpilleren køber Click Power level 2 for 10 mønter, samler så (sat op i tempo) 1 000 mønter og laver en rebirth: mønter og opgraderinger nulstilles, og hvert klik er værd x2.

En simulator er en løkke af tre handlinger. Spilleren gør noget enkelt igen og igen for at tjene valuta, bruger den på opgraderinger, der giver den hurtigere, og når opgraderingerne bliver dyre, laver spilleren en rebirth: giver mønter og opgraderinger væk for en bonus, der bliver for altid, og stiger igen, nu hurtigere. I andre simulatorer løfter man håndvægte, graver eller samler ting i stedet for at klikke, men løkken nedenunder er den samme.

De tre handlinger i denne guides løkke
HandlingHvad den kosterHvad den giverHvem der afgør det
KlikIngentingMønter svarende til Click Power × (Rebirths + 1)Serveren, som højst tæller 15 klik i hvert vindue på ét sekund
Opgradering10 mønter, derefter 1.5 gange den forrige pris for hvert levelÉt level mere af Click Power, op til level 50Serveren, ud fra sin egen kopi af priserne
Rebirth1 000 mønter, derefter 3 gange den forrige pris for hver rebirthMønter tilbage til 0 og Click Power tilbage til level 1, plus en permanent +1 til multiplikatorenServeren

Hvert tal lever på serveren. Spillerens enhed tegner knapperne og spørger ("jeg klikkede", "jeg vil have en opgradering"), og serveren afgør, hvad det koster, og om det kan lade sig gøre. Klikker-scripts, der bliver hacket, lægger ofte mønter til i et LocalScript eller lader klienten sende, hvor mange mønter der skal lægges til.

Hvad en simulator består af
ElementHvor det liggerHvad det gør
ModuleScript SimulatorConfigReplicatedStoragePriser, grænser og formler for et kliks værdi, en opgraderings pris og en rebirths pris. Begge sider læser det.
Script SimulatorServiceServerScriptServiceHolder hver spillers tal, håndterer klik, opgraderinger og rebirths og udfylder leaderstats.
Folder SimulatorRemotesReplicatedStorage (oprettes af SimulatorService)RemoteEvent Click og RemoteFunctions BuyUpgrade og Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsBygger knapperne, sender klik og forespørgsler og viser serverens tal.
ModuleScript PlayerData (valgfrit)ServerScriptServiceGemmer fremskridtet mellem besøg. Det kommer fra tutorialen om DataStore og skal kun bruges til trin 4.
Explorer under spillet. SimulatorService opretter SimulatorRemotes og de tre remotes, når spillet starter, og PlayerData dukker først op, når du tilføjer gemning i trin 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

Trin 1: læg priser og formler i et modul

Hvert tal, du kunne finde på at justere, kommer i ét ModuleScript: hvad et klik er værd, hvad hver opgradering og rebirth koster, og grænsen for klik. Serveren afgør ud fra det, og LocalScriptet tager priserne til knapperne fra det, så enhver ændring er én rettelse ét sted.

  1. Hold markøren over ReplicatedStorage i Explorer, klik på knappen +, og indsæt et ModuleScript.
  2. Omdøb det til SimulatorConfig (navne skelner mellem store og små bogstaver), og erstat indholdet med koden nedenfor.
ModuleScript i ReplicatedStorage med navnet SimulatorConfig
-- Alle grundløkkens tal og de formler, som begge sider bruger. Klienten viser kun
-- priser ud fra dem; serveren afgør ud 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 gange det forrige
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- mønter til den første rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- hver rebirth koster 3 gange den forrige
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- klik ud over dette på ét sekund ignoreres

-- Mønter pr. klik: Click Power-level ganget med 1 + antallet af rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Prisen for næste level af Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- Mønter, der skal til for næste rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

Spillere kan læse et ModuleScript i ReplicatedStorage, så disse priser er offentlige. Det er fint: de står jo også på knapperne. Klienten og serveren kører hver deres egen kopi af modulet, så en spiller, der ændrer tallene på sin enhed, ikke ændrer noget på serveren.

Hvad formlerne giver med disse indstillinger
Click Power-levelPris for næste levelMønter pr. klik, uden rebirthsMønter pr. klik, 1 rebirth
11012
21524
32236
43348
550510

Rebirths koster 1 000 mønter, så 3 000, så 9 000, fordi rebirthCost ganger prisen med 3 hver gang. Efter én rebirth er hvert klik værd dobbelt så meget, efter to tre gange så meget, og så videre.

Hvor lang tid en rebirth tager med disse tal

Formlerne afgør, hvor længe løkken varer, så det er værd at regne tallene ud, før spillerne gør det. Tabellen går ud fra, at spilleren laver en rebirth, så snart den har råd, og resten af tiden køber næste level af Click Power, når den har råd, og det koster mindre end en rebirth. Tiden regnes fra en ny start, så den sidste kolonne er den samlede tid til 3 rebirths.

Minutter fra ny start til hver rebirth ved 5 klik i sekundet, efter REBIRTH_BASE_COST. Regnet ud fra formlerne i SimulatorConfig, ikke målt på spillere
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1 000 (denne guide)1.22.74.8
5 0004.310.118.3
10 0008.216.933.2
25 00016.740.174.5
50 00032.868.8137.8

Uden rebirths kommer Click Power level 5 efter 34 klik, level 10 efter 122 og level 13 efter 285. Med standardtallene holder spilleren derefter op med at opgradere, fordi level 14 koster 1 297 mønter, mere end en rebirth til 1 000 mønter, og den første rebirth kommer efter 362 klik i alt. Med serverens grænse på 15 klik i sekundet skal du dividere hver tid med 3. Ændrer du et hvilket som helst tal i SimulatorConfig, ændrer disse tider sig med, så regn dem ud igen.

Justering af væksten

De to tal _GROWTH bestemmer, hvor hurtigt priserne stiger. Ved 1.5 koster hver opgradering halvanden gang så meget som den forrige, mens hvert level kun lægger én mønt til pr. klik (før rebirth-multiplikatoren), så hvert nyt level tager længere tid at tjene ind. Det er netop den opbremsning, der gør en rebirth værd. Hæv væksten for en længere opstigning, sænk den for en hurtigere, og hold REBIRTH_BASE_COST højt nok til, at spillerne køber nogle opgraderinger før den første rebirth.

Hvis den første rebirth skal komme efter nogle minutter i stedet for efter cirka ét, så hæv REBIRTH_BASE_COST til 5 000 eller 10 000.

Trin 2: tilføj server-scriptet

Dette Script ejer hvert tal. Det opretter remotes, giver hver spiller en mappe leaderstats med Coins og Rebirths og svarer på tre forespørgsler. Hold markøren over ServerScriptService, indsæt et Script, omdøb det til SimulatorService, og erstat indholdet med denne kode:

Script i ServerScriptService med navnet SimulatorService
-- Ejer hvert tal: klik giver mønter her, opgraderinger og rebirths købes her,
-- og leaderstats viser kun resultatet.

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

-- false: alle starter fra nul ved hvert besøg. true: indlæsning og gemning via modulet PlayerData
-- fra tutorialen om DataStore (tilføj først PowerLevel = 1 og Rebirths = 0 i dets 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 } = {} -- hvornår spillerens nuværende sekundvindue startede
local clickCount: { [Player]: number } = {} -- klik, der er talt med i dette vindue

-- Kopierer serverens tal derhen, hvor spillerne ser dem: til leaderstats og én attribut
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 givne data (nye tal eller en gemt 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

-- Et klik bærer ingen tal: hvad det er værd, regner serveren ud
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 script, der kalder 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 mønter og opgraderinger for 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

-- Starttal: nye eller den tabel, som modulet PlayerData indlæser og gemmer
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 tabel, som PlayerData gemmer, så hver ændring bliver gemt
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- alle, hvis data blev indlæst, før dette script startede
	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 frem til spilleren som attributten PowerLevel på spillerens Player-objekt og ikke som en tredje værdi i leaderstats, så spillerlisten kun viser Coins og Rebirths. Attributter, som serveren sætter, replikeres til spillerens enhed; en ændring, som spilleren laver på sin enhed, bliver der.

Klik og grænse for hyppighed

Remoten Click sender ingen argumenter. På serveren er den første parameter i handleren OnServerEvent altid den spiller, der kaldte den, så serveren ved, hvem der klikkede, tager spillerens Click Power-level og Rebirths og lægger clickValue til spillerens Coins. Der er intet i forespørgslen, som en snyder kunne ændre.

Roblox' guide til sikkerhed siger, at man aldrig må stole kun på en grænse for hyppighed på klienten, og udbetaling af valuta står blandt de handlinger, der skal begrænses. Serveren tæller hver spillers klik i vinduer på ét sekund: det første klik åbner et vindue, og når 15 klik er talt med, ignoreres resten, indtil der er gået et sekund siden vinduets start. Et script, der kalder remoten i en løkke, får højst 15 talte klik i hvert vindue. For at tillade hurtigere eller langsommere klik skal du ændre MAX_CLICKS_PER_SECOND i SimulatorConfig.

Opgraderinger og rebirths

BuyUpgrade og Rebirth er RemoteFunctions, så knappen kan vente på svaret og vise det. Hver handler tager prisen fra serverens kopi af SimulatorConfig, tjekker spillerens Coins og ændrer først derefter noget. Den returnerer true eller false og en besked, for eksempel "You need 5 more coins.", som LocalScriptet viser i statuslinjen.

Mellem tjekket af prisen og ændringen venter intet og giver intet kørslen fra sig (yield), så to forespørgsler fra samme spiller kan ikke begge komme igennem tjekket, før den første har taget mønterne. En rebirth sætter Coins til 0, Click Power til level 1 og lægger 1 til Rebirths, og klikformlen gør det til multiplikatoren Rebirths + 1.

Kontakten SAVE_PROGRESS

Med SAVE_PROGRESS = false starter hver spiller med 0 mønter ved hvert besøg, og det er det, du vil have, mens du bygger spillet. Trin 4 slår den til. Så venter scriptet på, at modulet PlayerData indlæser hver spiller, og arbejder direkte med den tabel, som modulet gemmer, så hver mønt og hver rebirth bliver gemt uden ekstra kode.

Trin 3: byg knapperne

Dette LocalScript bygger hele skærmen i kode: en møntæller øverst, en stor Click-knap i midten, knapperne Upgrade og Rebirth nederst og en statuslinje til serverens svar. Selv ændrer det aldrig et eneste tal.

  1. Fold StarterPlayer ud i Explorer, hold markøren over StarterPlayerScripts, og indsæt et LocalScript med navnet SimulatorClient.
  2. Erstat indholdet med koden nedenfor, og tryk på Play.
LocalScript i StarterPlayerScripts med navnet SimulatorClient
-- Bygger simulatorens knapper og viser serverens tal. Selv ændrer det dem aldrig.

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 forbliver kvadratisk, tilpasset skærmen og ikke større end 200 gange 200,
-- så den på en telefon er plads mellem møntælleren og knapperne 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 popper op over knappen. Tallet er kun et gæt for udseendets skyld;
-- hvad et klik faktisk er værd, afgør 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)

Knapperne bruger Activated, som Roblox udløser ved et venstreklik med musen på en computer, ved et tryk på en telefon og ved et tryk på A (eller krydset) på en gamepad i UI-navigationstilstand.

På en gamepad trykker A kun på den valgte knap. Når GuiService.AutoSelectGuiEnabled er slået til, vælger knappen Select på gamepaden dine knapper på skærmen; derefter kan spillerne skifte mellem dem og trykke på A. Hvis du vil have en gamepad-knap til at klikke med det samme, så bind den med ContextActionService, og kald den samme remote Click fra den.

Fire detaljer i scriptet:

  • Click-knappen skalerer med skærmen. Dens størrelse er en andel af skærmen, UIAspectRatioConstraint holder den kvadratisk, og UISizeConstraint begrænser den til 200 gange 200 pixels. På en skærm er den 200 pixels bred; på en telefon bliver den mindre og passer mellem møntælleren og knapperne nederst. Hvis du flytter elementer, så hold den væk fra dem: Rebirth har ingen bekræftelse, så et utilsigtet tryk kan nulstille spillerens mønter og opgraderinger.
  • Det "+N", der popper op, er kun for udseendets skyld. Det bruger klientens kopi af formlen. Hvis serveren ignorerer et klik på grund af grænsen for hyppighed, dukker "+N" alligevel op, men mønterne ændrer sig ikke.
  • short() gør store tal læsbare. 1 234 vises som 1.2K, og 5 600 000 som 5.6M. Funktionen runder ned, så tælleren aldrig viser mere, end du har. Til tal over T (billioner) skal du tilføje poster i UNITS.
  • Skærmen opdateres via events. Den lytter efter værdierne Coins og Rebirths og attributten PowerLevel, så priserne på knapperne er rigtige, uanset hvordan tallene ændrer sig.

ScreenGuien har ResetOnSpawn sat til false, så den bliver, når karakteren genopstår. Her er det vigtigt: et LocalScript i StarterPlayerScripts kopieres til spilleren én gang, ved indgang, så det ville ikke bygge skærmen igen.

Trin 4: gem fremskridtet med PlayerData

Indtil videre nulstilles alt, når spilleren går. I stedet for et ekstra gemme-script kobler simulatoren sig til modulet PlayerData fra tutorialen om DataStore. Det modul prøver allerede mislykkede forespørgsler igen, gemmer automatisk hvert 180. sekund, gemmer, når spilleren går, og når serveren lukker, og gemmer aldrig en spiller, hvis data ikke blev indlæst.

  1. Følg trin 1 i tutorialen om DataStore for at tilføje ModuleScriptet PlayerData i ServerScriptService. For at teste gemning i Studio skal du slå Studios adgang til API-tjenester til i en testkopi af spillet, som dens første afsnit forklarer. SimulatorService henter selv modulet med require, så scriptet Main fra tutorialen skal ikke bruges her.
  2. Tilføj i PlayerData PowerLevel = 1, og Rebirths = 0, i tabellen DEFAULTS, ved siden af Coins = 0,.
  3. Tilføj i samme modul PowerLevel: number, og Rebirths: number, i typen Data, så det strenge typetjek kender de nye felter.
  4. Erstat i SimulatorService local SAVE_PROGRESS = false med local SAVE_PROGRESS = true.

Spillere, der blev gemt, før du tilføjede felterne, får dem automatisk: funktionen migrate i PlayerData udfylder alle felter fra DEFAULTS, som mangler i den gemte tabel, så de starter med Click Power level 1 og 0 rebirths og beholder deres Coins. Hvis du springer punkt 2 over, udskriver SimulatorService en advarsel med de felter, der skal tilføjes, og starter ikke spilleren.

Hvorfor simulatoren skriver i PlayerDatas tabel

Når gemning er slået til, kopierer SimulatorService ikke tallene nogen steder hen. PlayerData.Get(player) returnerer den levende tabel, som modulet gemmer, og simulatoren ændrer Coins, PowerLevel og Rebirths i netop den tabel. Hvert tal har én kopi, og ét script skriver til datastore. To scripts, der gemmer den samme nøgle, overskriver hinanden, og det ene kan gemme gamle tal oven i det andets tal.

Lav ikke også leaderstats i handleren Loaded, som tutorialen om DataStore anbefaler til andre spil: SimulatorService laver allerede Coins og Rebirths ud fra den indlæste tabel. Hvis et leaderboard-script allerede laver leaderstats, så slet det.

Hvorfor man ikke skal gemme ved hvert klik

Roblox tillader hver server 60 + 40 × spillere skrivninger til en almindelig datastore i minuttet (resten står i tabellen over grænser i tutorialen om DataStore). At gemme ved hvert klik ved 15 klik i sekundet er 900 skrivninger i minuttet for én spiller, langt mere end de 100, en server med én spiller får. At gemme hele tabellen hvert 180. sekund, når spilleren går, og når serveren lukker, koster kun nogle få skrivninger pr. spiller, og ved et nedbrud går højst fremskridtet siden sidste automatiske gemning tabt.

Hvis indlæsningen mislykkedes, lader modulet spilleren spille med nye tal, men gemmer dem aldrig, så en dårlig indlæsning ikke kan overskrive rigtigt fremskridt. Tutorialen forklarer, hvordan modulet håndterer det.

Hvorfor serveren afgør hvert tal

Exploitere styrer deres egen enhed. Roblox' guide til sikkerhed siger, at de kan ændre hvad som helst i deres lokale kopi af spillet og kalde enhver RemoteEvent eller RemoteFunction så mange gange, de vil, med hvilke argumenter som helst. En simulators økonomi er præcis så sikker som dens server-script.

Hvad en exploiter kan prøve, og hvad SimulatorService gør
Exploiteren prøver atHvis klienten afgjorde detHvad SimulatorService gør
Kalde Click i en løkke så hurtigt som muligtUendelige mønterTæller højst 15 klik i hvert sekundvindue og ignorerer resten.
Sende et antal mønter med klikketHan vælger selv sin belønningIgnorerer alle argumenter. Et kliks værdi kommer fra serverens tal.
Købe en opgradering eller rebirth uden de nødvendige mønterGratis opgraderingerSammenligner prisen med Coins på serveren og svarer "You need N more coins."
Ændre Coins i leaderstats på sin skærmBruge mønter, han ikke harLæser aldrig leaderstats. Den skriver kun dertil fra sin tabel.
Sætte attributten PowerLevel på sin PlayerEt stærkere klikLæser aldrig den attribut, og ændringen bliver på spillerens enhed.
Kalde Rebirth to gange i samme øjeblikTo rebirths til prisen for énTjekker prisen igen ved hvert kald, og mellem tjekket og ændringen giver intet kørslen fra sig.
Ændre priserne i sin kopi af SimulatorConfigBilligere opgraderingerBruger sin egen kopi af modulet.

Reglen gælder for hver remote i simulatoren: send det, spilleren vil gøre, ikke hvad det koster. Guiden til RemoteEvent gennemgår tjek af remotes' argumenter mere i detaljer.

Hvad du skal undgå i kopierede klikker-scripts

Almindelige greb fra gamle klikker-tutorials, og hvad denne guide gør i stedet
GrebProblemDenne guide
Et LocalScript lægger mønter til med leaderstats.Coins.Value += 1Ændringen bliver på én enhed, og sin enhed styrer exploiterenServeren lægger mønter til
clickEvent:FireServer(amount)Klienten vælger selv sin belønningClick sender ingen argumenter
Ingen grænse for hyppighed på serverenRoblox-dokumentationen siger, at man aldrig må stole kun på en grænse på klientenHøjst 15 klik i hvert sekundvindue
SetAsync ved hvert klik eller hver opgraderingÆder serverens skrivegrænsePlayerData gemmer hvert 180. sekund, når spilleren går, og ved lukning. Gem kun med det samme med PlayerData.SaveNow efter noget, der ikke må gå tabt, for eksempel køb for Robux.
Et ekstra datastore-script kun til simulatorenTo scripts, der gemmer den samme nøgle, overskriver hinandenSkriver i PlayerDatas tabel
Løkker med while wait(1) do til passiv indkomstRoblox markerer den globale wait som forældet, den erstattes af task.waittask.wait (se Sådan udvider du)
MouseButton1Click på knapperBeskrevet til museklikActivated, til mus, tryk og gamepad

Trin 5: test det

Gennemgå punkt 1 til 8 med SAVE_PROGRESS = false i SimulatorService, så hver playtest starter med nye tal. Hvis du allerede har slået gemning til i trin 4, så sæt den til false indtil videre, og sæt den tilbage til true til punkt 9.

  1. Tryk på Play. Øverst på skærmen står der 0 coins, på den grønne knap Upgrade: 10 og på den orange Rebirth: 1.0K.
  2. Tryk på den lilla knap Click! ti gange. Hvert klik viser et gyldent +1, og Coins i spillerlisten stiger med 1.
  3. Tryk på Upgrade. Mønterne går tilbage til 0, statuslinjen bliver grøn med teksten "Click Power is now level 2.", og knappen siger nu Upgrade: 15. Fra nu af giver hvert klik 2 mønter.
  4. Tryk på Rebirth uden at klikke. Statuslinjen skriver "You need 1000 more coins to rebirth.", og intet ændrer sig.
  5. For at teste en rebirth uden 1 000 klik skal du stoppe testen, ændre Coins = 0 til Coins = 1000 i linjen nær slutningen af SimulatorService, som starter nye spillere, og trykke på Play. Tryk på Rebirth: Coins bliver 0, Rebirths i spillerlisten bliver 1, statuslinjen skriver "Rebirth 1! Every click is now worth x2.", og knappen siger nu Rebirth: 3.0K. Hvert klik giver nu 2 mønter på Click Power level 1. Sæt derefter linjen tilbage til 0.
  6. For at se grænsen for hyppighed skal du sætte MAX_CLICKS_PER_SECOND i SimulatorConfig til 2 og klikke hurtigt. "+N" bliver ved med at dukke op, men Coins stiger højst med værdien af 2 klik i sekundet. Sæt den tilbage til 15.
  7. Vælg en telefon i Device Simulator i Studio (det er en Studio-beta; den gamle Device Emulator virker også), og tryk på Play. Tjek, at Click-knappen ikke går ind over møntælleren eller knapperne Upgrade og Rebirth, og at statuslinjen er synlig og ikke dækkes af en knap, når du trykker på Upgrade.
  8. Tilslut en gamepad, eller åbn Controller Emulator i Studio (Controller på fanen Emulation) under en playtest, tryk på Select, og tjek, at du kan nå alle tre knapper og trykke på dem med A.
  9. Med gemning slået til (trin 4) og igen SAVE_PROGRESS = true skal du tjene nogle mønter, trykke på Stop og så Play igen. Dine Coins, dit Click Power-level og dine Rebirths kommer tilbage.

Lav en træningssimulator eller en minesimulator

Mange simulatorer erstatter knappen med en handling i verden: løft en håndvægt, sving en hakke, sving et sværd i luften. Nedenunder er det det samme klik. Et Tool kan kalde den samme remote Click, så SimulatorService, dets priser og dets grænse for hyppighed forbliver, som de er.

  1. Hold markøren over StarterPack i Explorer, indsæt et Tool, og kald det Dumbbell. Indsæt en Part med navnet Handle i det, giv den form som en håndvægt, og fjern fluebenet i Anchored, som i trinene med Tool i guiden til sværd.
  2. Indsæt et LocalScript med navnet LiftClient i toolet, og sæt koden nedenfor ind.
  3. Tryk på Play, tag håndvægten, og klik. Mønterne stiger med din Click Power for hvert løft, præcis som med knappen.
LocalScript i toolet Dumbbell i StarterPack med navnet LiftClient
-- LocalScript inde i toolet Dumbbell, med navnet LiftClient.
-- Hvert løft er et klik: det kalder den samme remote Click som knappen, og serveren
-- afgør, hvad det er værd, og hvor mange løft der tælles 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 mellem løft på denne enhed; serveren har sin egen grænse
local LIFT_ANIMATION_ID = "" -- valgfrit: "rbxassetid://" efterfulgt af id for din animation

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

-- Indlæs løfteanimationen én gang pr. karakter via den Animator, som Roblox lægger 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() -- uden argumenter: belønningen regner serveren ud
end)

Til en løfteanimation skal du lave den i Animation Editor med prioriteten Action, udgive den og sætte dens ID ind i LIFT_ANIMATION_ID. Trinene med animation fra guiden til sværd virker på samme måde.

  • Tilpas serverens grænse til handlingen. LIFT_SECONDS bremser kun ærlige spillere: en snyder kan kalde Click fra sin egen kode. Hvis løftet er den eneste måde at tjene på, så sænk MAX_CLICKS_PER_SECOND i SimulatorConfig til det reelle tempo, for eksempel til 2 for ét løft hvert 0.5 sekund, så et script ikke kan tjene mere end en spiller. Regn derefter tempotabellen ud igen: hver tid i den er beregnet ud fra 5 klik i sekundet.
  • Behold eller skjul knappen. Click-knappen virker fortsat ved siden af toolet. For at skjule den skal du tilføje clickButton.Visible = false lige efter den linje i SimulatorClient, der opretter clickButton.
  • Kun indtjening på det rigtige sted. For kun at betale i træningscentret eller i minen skal du på serveren tjekke, hvor karakteren er, før et klik tælles med, for eksempel ud fra afstanden til en part i den zone. Et tjek i LiftClient ville ikke stoppe nogen.

Hvad du skal gøre bagefter: byggerækkefølgen for en simulator

En simulator er en stak systemer oven på denne løkke. Byg dem i denne rækkefølge, så hvert system har noget at gange, og lav en playtest efter hvert. Her er den rækkefølge, vi anbefaler, med en guide til hvert trin.

Byggerækkefølgen for en simulator i Roblox, fra grundløkken og udad
RækkefølgeSystemGuideHvorfor netop nu
1Indtjening, opgradering, rebirthDenne guideAlt andet ganger denne løkke, så juster først dens tal efter tempotabellen.
2GemningTutorialen om DataStore, derefter trin 4Fremskridt, der nulstilles, når man kommer ind igen, dræber en simulator. Tilføj det før alt, hvad spillerne kan miste.
3Æg og pets som multiplikatorerÅbning af æg og pets, der følger spillerenEt andet mål ved siden af mønterne: noget, man kan samle, og som gør hvert klik mere værd.
4Zoner bag rebirthsSådan udvider duHvor man kan gå hen efter en rebirth, med bedre belønninger, som serveren tjekker.
5LeaderboardsGuiden til leaderboardsEn global top 10 over rebirths giver den lange opstigning mening.
6Daglige belønninger og koderDaglige belønninger og koderGrunde til at komme tilbage i morgen og efter hver opdatering.
7GamepassesGuiden til gamepasses2x mønter, autoklik eller en ekstra plads til et pet, med tjek på serveren. Sælg dem, når den gratis løkke allerede er sjov.

Til skærmene indeholder de gratis UI-kits til Roblox skærme i simulatorstil sammen med de scripts, der får dem til at virke.

Sådan laver du en simulator uden at skrive scripts

En simulator har stadig brug for scripts: nogen skal lægge mønter til, tjekke priser og gemme. Du behøver ikke at skrive dem selv:

  • Et simulator-kit fra Creator Store. Læs dets scripts før udgivelse, og tjek, at mønterne kun ændres i et Script på serveren, ikke i et LocalScript.
  • Et plugin, der genererer simulatorer. Det samme tjek for alt, hvad det laver.
  • En AI-agent i Studio, for eksempel RoCode, som kan bygge de samme tre scripts i det place, du har åbent.
  • Build i Roblox' mobilapp. Ifølge Roblox-dokumentationen laver den enklere 2D- og 2.5D-spil ud fra en beskrivelse, for eksempel klikkere, og rulles gradvist ud efter region.

Uanset hvad du vælger, så kør tjekkene fra trin 5 og tjekkene for exploits fra afsnittet Hvorfor serveren afgør hvert tal på resultatet.

Sådan udvider du: pets, zoner, autoklik og leaderboards

Pets som multiplikatorer

En almindelig variant: hvert pet er en multiplikator. Gem listen over spillerens pet-id i spillerens gemte tabel, og lad serveren gange clickValue med bonussen fra hvert pet, spilleren har på. Åbn æg på serveren: klienten beder om at åbne et æg, serveren tjekker og tager prisen og vælger derefter et pet med et vægtet tilfældigt kast. Lad aldrig klienten kaste for et æg eller sige, hvilket pet der kom ud. Guiden til inventar viser, hvordan du gemmer, lagrer og viser spillerens ting, og pets virker på samme måde. Guiden til åbning af æg bygger kastet på serveren, og guiden til pets får pets til at flyve ved siden af ejeren.

Zoner, der låses op med rebirths

En zone er en del af kortet med bedre belønninger bag en barriere. Lås belønningen, ikke kun døren: alt, hvad der betaler inde i zonen, skal tjekke spillerens Rebirths i serverens tabel, før det betaler. En dør, som et LocalScript åbner for de rette spillere, er fin til udseendet, men exploitere kan ændre parts og flytte deres karakter på deres egen enhed.

Autoklik som gamepass

En autoklikker, der sælges som gamepass, skal køre på serveren. Flyt kroppen af Click-handleren ind i en funktion, for eksempel addClick(player), forbind remoten til den, og kald den for passets ejere fra en server-løkke med task.wait(0.5) og ikke med den forældede wait. Så tæller autoklik med i den samme grænse pr. sekund som almindelige klik. Tjek ejerskab på serveren med MarketplaceService:UserOwnsGamePassAsync, som guiden til gamepasses gør for sine bonusser. Et pass med 2x mønter virker på samme måde: gang clickValue på serveren for ejerne. Før du sætter en pris, viser den gratis Robux-skatteberegner, hvor meget hvert salg giver dig efter Roblox' andel, og DevEx-beregneren viser, hvad de Robux er værd i amerikanske dollars.

En global top 10 over rebirths

leaderstats sammenligner kun spillere på én server. For at rangere alle spilleres Rebirths skal du skrive dem i en ordnet datastore (ordered data store) og læse de øverste poster tilbage, som i trin 4 i guiden til leaderboards. Ordnede datastores tillader færre skrivninger end almindelige, 30 + 5 × spillere i minuttet pr. server, så skriv, når spilleren går, og med en timer.

Meget store tal

Tal i Luau er doubles, de holder omkring 15 betydende cifre. IntValue holder heltal op til cirka 9.2 trillioner, men Roblox advarer om, at værdier over 2^53 (omkring 9 billiarder) mister præcision i scripts. Med disse indstillinger passerer rebirth-prisen den grænse ved rebirth nummer 29. Hvis dit spil går længere, så skift værdierne i leaderstats til NumberValue (erstat IntValue i begge scripts), som holder langt større tal med den samme præcision på cirka 15 cifre, og tilføj suffikser i short().

Hvad et simulatorspil hviler på

En simulator er et spil med tal. Klik, opgradering og rebirth ovenfor er hele løkken; om spillerne bliver, afgøres af, hvordan de tal vokser. Hvert par minutter skal spilleren have råd til noget, der gør de næste par minutter hurtigere, og hver session skal slutte tæt på et mål, man har lyst til at komme tilbage for.

  • Vækst, der holder længe. Priserne på opgraderinger stiger hurtigere end indtjeningen, så hvert trin tager lidt længere tid. En rebirth nulstiller mønterne for en permanent multiplikator, og den gamle zone bliver hurtig, mens opstigningen føles ny.
  • Noget at samle. Zoner, der skal låses op, pets fra æg, der ganger indtjeningen, og tools, der kan opgraderes, giver spillerne en liste over mål ud over ét tal.
  • Store tal, der forbliver læsbare. Vis 1.5M og ikke 1500000, og gem tallene, så serveren kan sammenligne dem, også når de bliver store.

Monetisering, der passer til en simulator

Almindelige passes ganger mønter, giver en ekstra plads til et pet, åbner flere æg ad gangen eller slår autoklik til. Sælg dem som gamepasses, og tjek dem på serveren. Møntpakker er developer products. Hvis æg eller noget andet med et tilfældigt resultat kan købes for Robux eller for en valuta købt for Robux, kræver Roblox, at sandsynlighederne vises før købet: læs paid random items (på engelsk), før du bygger butikken.

Hvad der får spillerne tilbage

Gemt fremskridt, en ny zone eller et sæt pets i opdateringer, daglige belønninger, koder, der annonceres sammen med opdateringer, og et leaderboard over rebirths. Andre genrer, hver med sin egen løkke, systemer og byggeplan: spilgenrer i Roblox.

Almindelige fejl og løsninger

Åbn vinduet Output (menuen Window og derefter Output), før du trykker på Play. De fleste problemer udskriver dér en advarsel eller fejl med scriptets navn og linjen.

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

LocalScriptet venter på de remotes, som SimulatorService opretter ved start. Tjek, at SimulatorService er et Script og ikke et LocalScript, at det ligger i ServerScriptService, og at der ikke er nogen fejl fra det i Output. Den samme advarsel for SimulatorConfig betyder, at modulet ikke ligger i ReplicatedStorage eller har et andet navn.

Knapperne dukker aldrig op

LocalScriptet venter på dine leaderstats, før det bygger skærmen. Hvis Output skriver Infinite yield possible på leaderstats, har SimulatorService endnu ikke startet dig. Med SAVE_PROGRESS = true venter det på PlayerData, så tjek, at PlayerData ligger i ServerScriptService og indlæses uden fejl.

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

Gemning er slået til, men modulet PlayerData har endnu ikke de nye felter. Tilføj dem i dets DEFAULTS, som i trin 4, og tryk på Play igen.

"+1" popper op, men mønterne stiger ikke

Serveren tæller ikke klikkene med. Enten er der en fejl i SimulatorService (kig efter rød tekst fra det i Output), eller klikkene kommer hurtigere, end MAX_CLICKS_PER_SECOND tillader. Hvis spillerne rammer grænsen ved almindeligt spil, så hæv den i SimulatorConfig.

Statuslinjen skriver "No answer from the server. Try again."

Kaldet til BuyUpgrade eller Rebirth gik ned i stedet for at returnere et svar. Den sædvanlige årsag er en fejl inde i SimulatorService, mens forespørgslen blev behandlet, så kig efter en rød fejl fra det i Output: den nævner linjen.

Møntælleren på skærmen og spillerlisten viser forskellige tal

Et andet script laver også en mappe leaderstats, så hver spiller har to, og LocalScriptet kan læse den anden. Slet det overskydende script: SimulatorService laver selv Coins og Rebirths.

Mønterne nulstilles, hver gang jeg kommer ind igen

Gemning er slået fra. Følg trin 4. Hvis den er slået til, og mønterne stadig nulstilles i Studio, så tjek, at Studios adgang til API-tjenester er slået til i testkopien, som tutorialen om DataStore forklarer.

Lav det med RoCode

Hvis du ikke har lyst til at sætte det ind i hånden, kan RoCode bygge det i det place, du har åbent. Det er en uafhængig AI-agent til kode, ikke fra Roblox: du beskriver systemet i dens webchat, og dens plugin til Roblox Studio opretter scripts i din Explorer, så du ikke skal kopiere kode fra chatvinduet.

Du skriver

Lav en klikker-simulator: en stor Click-knap, der giver mønter svarende til mit Click Power-level ganget med (rebirths + 1), en Upgrade-knap, der koster 10 mønter og bliver 1.5 gange dyrere for hvert level, og en Rebirth-knap til 1 000 mønter, der nulstiller mønter og opgraderinger. Hold tallene på serveren, og begræns klik til 15 i sekundet. Jeg har allerede et PlayerData-modul.

RoCode gør
  • Kan først læse dit PlayerData-modul og ethvert leaderstats-script med Search Scripts og Read Script for at tilføje felter i dine eksisterende data i stedet for at skrive et ekstra gemme-script
  • Kan lave et udkast til skærmen med HUD-layoutet i Build UI (med plugin 3.9 eller nyere, i simulatorstil) eller bygge knapperne i et LocalScript, og skriver ModuleScriptet, server-Scriptet og LocalScriptet med Create Script
  • Er instrueret i at tjekke kompileringen af hvert script, den skriver, med Check Script, som kompilerer det i Studio uden at køre det
  • Sætter et fortryd-punkt før og efter hver omgang ændringer, så Ctrl+Z ruller én omgang tilbage ad gangen

RoCode kan ikke oprette gamepasses og developer products eller uploade meshes og ikoner til pets: det gøres i Creator Hub og Studio. Med plugin 3.9.11 eller nyere kan RoCode køre en playtest af dit spil i Studio og styre en testkarakter for at tjekke, at alt virker, og med plugin 3.9.15 eller nyere kan testkarakteren trykke på knapper på skærmen, for eksempel trykke på Click og tjekke, at Coins steg. Den bestemmer selv, hvornår den kører en playtest, op til 2 pr. bygning plus 1 for at tjekke sin rettelse, og tjekker kun det, den har valgt, så tjek selv løkken. En hel simulator er flere prompts, ét system ad gangen: sådan bygger du med RoCode ét system pr. prompt. Sådan forbinder RoCode til Studio.

Ofte stillede spørgsmål

Hvordan laver man en simulator i Roblox uden scripts?

En fungerende simulator har brug for scripts: nogen skal lægge mønter til, tjekke priser og gemme fremskridtet. Du kan sætte de tre scripts fra denne guide ind, som de er, og kun ændre tallene i SimulatorConfig, eller lade et kit fra Creator Store, et plugin eller en AI-agent lave dem og tjekke, at serveren afgør mønterne. Mulighederne.

Hvordan virker et rebirth-system?

En rebirth bytter dine mønter og opgraderinger for en permanent bonus. I denne guide koster den første rebirth 1 000 mønter; den sætter Coins til 0, Click Power til level 1 og lægger 1 til Rebirths, og derefter ganges hvert klik med Rebirths + 1. Hver rebirth koster tre gange så meget som den forrige.

Hvordan laver man en styrke- eller træningssimulator?

Giv spillerne et Tool, for eksempel en håndvægt, hvis LocalScript kalder den samme remote Click ved Tool.Activated. Serveren regner belønningen ud præcis som for et klik på knappen. Sænk serverens grænse for klik til tempoet for løft, så et script ikke kan tjene mere end en spiller. Scriptet står i afsnittet versionen med håndvægt.

Hvilke systemer skal en simulator have?

Først løkken med indtjening, opgraderinger og rebirths, så gemning, så pets eller en anden samling, der ganger indtjeningen, zoner bag rebirths, leaderboards, daglige belønninger og koder, og helt til sidst gamepasses. Byggerækkefølgen har en guide til hvert.

Hvor lang tid skal en rebirth tage?

Længe nok til, at spillerne først køber nogle opgraderinger, og kort nok til, at de når én i den første session. Med tallene i denne guide kommer den første rebirth efter cirka 1.2 minutter ved 5 klik i sekundet; hvis du hæver REBIRTH_BASE_COST til 10 000, bliver det omkring 8 minutter. Flere indstillinger i tempotabellen.

Hvordan beskytter man sig mod autoklikkere?

Serveren tæller højst 15 klik pr. spiller i hvert sekundvindue og ignorerer resten. Under den grænse ser et script ud som en hurtig spiller, så det er netop grænsen, der beskytter økonomien. Du kan også sælge autoklik som et gamepass, der kører på serveren.

Hvorfor nulstilles mønterne, når man kommer ind igen?

Intet gemmer dem endnu. Tilføj modulet PlayerData fra tutorialen om DataStore, tilføj PowerLevel og Rebirths i dets DEFAULTS, og sæt SAVE_PROGRESS = true i SimulatorService, som i trin 4.

Hvordan tilføjer man pets til en simulator?

Gør hvert pet til en multiplikator, som serveren bruger på klik. Åbn æg på serveren med et vægtet tilfældigt valg, gem spillerens pet-id sammen med resten af spillerens data, og vis dem i en inventar-GUI, som i guiden til inventar.

Hvad er bedst: at klikke på en part eller på en knap?

Begge virker. En knap på skærmen er praktisk på telefoner, og en part med ClickDetector passer til et spil, hvor alt foregår i verden. Ifølge Roblox-dokumentationen tjekker serveren slet ikke ClickDetector-events, så begræns hyppigheden af de klik på serveren på samme måde.

Kilder og videre læsning

Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.

Prøv RoCode i dit eget spil.

Gratis credits hver dag, intet kort. Installér pluginet, beskriv en funktion, og se hvad der dukker op i Studio.