Guide · Spelsystem

Så gör du en simulator i Roblox

Nästan alla simulatorer kretsar kring samma loop: du gör något enkelt och får valuta, spenderar den på uppgraderingar som ger den snabbare och gör sedan en rebirth för att börja om med en permanent multiplikator. I den här guiden bygger vi den loopen som en clicker med tre skript, där servern bestämmer varje tal, och sparar framstegen med modulen PlayerData från guiden om DataStore. Om du aldrig har gjort ett spel i Studio förut, gör först en kort myntbana.

Uppdaterad 20 november 202625 min läsningSkriven av

I korthet

En simulator i Roblox är en enda loop: klicka för att få mynt, spendera dem på uppgraderingar som ger mer och gör sedan en rebirth för en permanent multiplikator. Håll priserna i ett ModuleScript i ReplicatedStorage. Ett Script i ServerScriptService håller varje spelares Coins, Click Power och Rebirths, räknar högst 15 klick per sekund från RemoteEvent Click och säljer uppgraderingar och rebirths via en RemoteFunction efter att ha kontrollerat priset. Ett LocalScript visar knapparna Click, Upgrade och Rebirth. Med talen i den här guiden når en spelare som klickar 5 gånger per sekund sin första rebirth på ungefär 1.2 minuter, och tempotabellen visar vad du ska ändra för att klättringen ska ta längre tid.

  • Ett klick skickar ingenting annat än själva klicket. Vad det är värt räknar servern ut, så en modifierad klient kan inte ge sig själv mynt.
  • Spara hela tabellen med en timer och när spelaren lämnar, inte vid varje klick. Roblox tillåter varje server 60 + 40 × spelare skrivningar till data stores per minut.
  • Kan du inte skripta? Samma loop kan byggas av ett kit från Creator Store, ett plugin eller en AI-agent. Kontrollera att servern bestämmer över mynten: alternativen.
  • Behöver du ett gym eller en gruva i stället för en knapp? Ett Tool kan anropa samma remote Click: versionen med hantel. Lägg sedan till system enligt byggordningen nedan.
På den här sidan
  1. Så fungerar det
  2. 1. Inställningsmodulen
  3. 2. Serverskriptet
  4. 3. Knapparna
  5. 4. Sparande
  6. Varför servern bestämmer
  7. 5. Testa
  8. Versionen med hantel
  9. Byggordning
  10. Utan skriptning
  11. Så bygger du ut
  12. Genren
  13. Common errors
  14. Med RoCode
  15. Vanliga frågor
  16. Källor och vidare läsning

Så fungerar simulatorns grundloop

IllustrationSpelaren köper Click Power nivå 2 för 10 mynt, samlar sedan (snabbspolat) 1 000 mynt och gör en rebirth: mynt och uppgraderingar nollställs, och varje klick är värt x2.

En simulator är en loop med tre handlingar. Spelaren gör något enkelt om och om igen för att tjäna valuta, spenderar den på uppgraderingar som ger den snabbare, och när uppgraderingarna blir dyra gör spelaren en rebirth: lämnar ifrån sig mynt och uppgraderingar för en bonus som stannar för alltid och klättrar igen, nu snabbare. I andra simulatorer lyfter man hantlar, gräver eller samlar föremål i stället för att klicka, men loopen under är densamma.

De tre handlingarna i den här guidens loop
HandlingVad den kostarVad den gerVem som bestämmer
KlickIngentingMynt lika med Click Power × (Rebirths + 1)Servern, som räknar högst 15 klick i varje fönster på en sekund
Uppgradering10 mynt, sedan 1.5 gånger förra priset för varje nivåEn nivå till av Click Power, upp till nivå 50Servern, utifrån sin egen kopia av priserna
Rebirth1 000 mynt, sedan 3 gånger förra priset för varje rebirthMynt tillbaka till 0 och Click Power tillbaka till nivå 1, plus en permanent +1 till multiplikatornServern

Varje tal bor på servern. Spelarens enhet ritar knapparna och ber om saker ("jag klickade", "jag vill ha en uppgradering"), och servern bestämmer vad det är värt och om det går. Clickerskript som går sönder lägger ofta till mynt i ett LocalScript eller låter klienten skicka hur många mynt som ska läggas till.

Vad simulatorn består av
DelVar den finnsVad den gör
ModuleScript SimulatorConfigReplicatedStoragePriser, gränser och formler för klickvärde, uppgraderingspris och rebirthpris. Båda sidorna läser det.
Script SimulatorServiceServerScriptServiceHåller varje spelares tal, hanterar klick, uppgraderingar och rebirths och fyller i leaderstats.
Folder SimulatorRemotesReplicatedStorage (skapas av SimulatorService)RemoteEvent Click och RemoteFunction BuyUpgrade och Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsBygger knapparna, skickar klick och förfrågningar och visar serverns tal.
ModuleScript PlayerData (valfritt)ServerScriptServiceSparar framstegen mellan besöken. Den kommer från guiden om DataStore och behövs bara för steg 4.
Explorer under spelets gång. SimulatorService skapar SimulatorRemotes och de tre remotes när spelet startar, och PlayerData dyker upp först efter att du har lagt till sparande i 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: lägg priser och formler i en modul

Varje tal som du kan vilja justera går in i ett enda ModuleScript: vad ett klick är värt, vad varje uppgradering och rebirth kostar och gränsen för klick. Servern bestämmer utifrån det, och LocalScript hämtar priserna för knapparna därifrån, så varje ändring är en enda redigering på ett ställe.

  1. I Explorer, håll muspekaren över ReplicatedStorage, klicka på knappen + och infoga ett ModuleScript.
  2. Byt namn på det till SimulatorConfig (namn är skiftlägeskänsliga) och ersätt innehållet med koden nedan.
ModuleScript i ReplicatedStorage med namnet SimulatorConfig
-- Alla tal i grundloopen och formlerna som båda sidorna använder. Klienten bara
-- visar priser utifrån dem; servern bestämmer utifrån sin egen kopia.

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- priset för Click Power nivå 2
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- varje nivå kostar 1.5 gånger mer än den förra
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- mynt för den första rebirthen
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- varje rebirth kostar 3 gånger mer än den förra
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- klick utöver detta under en sekund ignoreras

-- Mynt per klick: nivån på Click Power gånger 1 + antalet rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Priset för nästa nivå av Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- Mynt som behövs för nästa rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

Spelare kan läsa ett ModuleScript i ReplicatedStorage, så de här priserna är publika. Det är okej: de står ju redan på knapparna. Klienten och servern kör var sin kopia av modulen, så en spelare som ändrar talen på sin enhet ändrar ingenting på servern.

Vad formlerna ger med de här inställningarna
Nivå på Click PowerPris för nästa nivåMynt per klick, inga rebirthsMynt per klick, 1 rebirth
11012
21524
32236
43348
550510

Rebirths kostar 1 000 mynt, sedan 3 000, sedan 9 000, eftersom rebirthCost multiplicerar priset med 3 varje gång. Efter en rebirth är varje klick värt dubbelt så mycket, efter två tre gånger så mycket, och så vidare.

Hur länge en rebirth tar med de här talen

Formlerna avgör hur lång loopen är, så det lönar sig att räkna på talen innan spelarna gör det. Tabellen antar att spelaren gör en rebirth så fort hen har råd, och annars köper nästa nivå av Click Power när hen har råd med den och den kostar mindre än en rebirth. Tiden räknas från en ny start, så sista kolumnen är den totala tiden till 3 rebirths.

Minuter från en ny start till varje rebirth vid 5 klick per sekund, efter REBIRTH_BASE_COST. Uträknat med formlerna i SimulatorConfig, inte uppmätt på spelare
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1 000 (den här guiden)1.22.74.8
5 0004.310.118.3
10 0008.216.933.2
25 00016.740.174.5
50 00032.868.8137.8

Utan rebirths kommer Click Power nivå 5 efter 34 klick, nivå 10 efter 122 och nivå 13 efter 285. Med standardtalen slutar spelaren uppgradera efter det, eftersom nivå 14 kostar 1 297 mynt, mer än en rebirth för 1 000 mynt, och den första rebirthen kommer efter totalt 362 klick. Med serverns gräns på 15 klick per sekund, dela varje tid med 3. Ändrar du något tal i SimulatorConfig ändras de här tiderna också, så räkna om dem.

Justera tillväxten

De två _GROWTH-talen styr hur snabbt priserna växer. Med 1.5 kostar varje uppgradering en och en halv gång mer än den förra, medan varje nivå bara lägger till ett mynt per klick (före rebirth-multiplikatorn), så varje ny nivå tar allt längre tid att betala sig. Det är just den inbromsningen som gör en rebirth lönsam. Höj tillväxten för en längre klättring, sänk den för en snabbare, och håll REBIRTH_BASE_COST högt nog för att spelarna ska köpa några uppgraderingar före den första rebirthen.

För att den första rebirthen ska komma efter några minuter i stället för efter ungefär en, höj REBIRTH_BASE_COST till 5 000 eller 10 000.

Steg 2: lägg till serverskriptet

Det här Script äger varje tal. Det skapar remotes, ger varje spelare en mapp leaderstats med Coins och Rebirths och svarar på tre förfrågningar. Håll muspekaren över ServerScriptService, infoga ett Script, byt namn på det till SimulatorService och ersätt innehållet med den här koden:

Script i ServerScriptService med namnet SimulatorService
-- Äger varje tal: klick ger mynt här, uppgraderingar och rebirths köps här,
-- och leaderstats visar bara resultatet.

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

-- false: alla börjar från noll vid varje besök. true: laddar och sparar via modulen PlayerData
-- från guiden om DataStore (lägg först till PowerLevel = 1 och Rebirths = 0 i dess 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 } = {} -- när den här spelarens aktuella sekundfönster började
local clickCount: { [Player]: number } = {} -- klick som räknats i det här fönstret

-- Kopierar serverns tal dit där spelarna ser dem: till leaderstats och ett 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

-- Startar spelaren med de givna datan (nya tal eller den sparade tabellen)
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

-- Ett klick bär inga tal: vad det är värt räknar servern 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 autoclicker eller ett skript som anropar remoten i en loop
	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 byter mynt och uppgraderingar 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

-- Starttal: nya, eller tabellen som modulen PlayerData laddar och sparar
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) -- samma tabell som PlayerData sparar, så varje ändring sparas
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- alla vars data laddades innan det här skriptet startade
	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 spelaren som attributet PowerLevel på spelarens Player-objekt, inte som ett tredje värde i leaderstats, så spelarlistan visar bara Coins och Rebirths. Attribut som servern sätter replikeras till spelarens enhet; en ändring som spelaren gör på sin enhet stannar där.

Klick och frekvensgräns

Remoten Click skickar inga argument. På servern är den första parametern i hanteraren OnServerEvent alltid spelaren som anropade den, så servern vet vem som klickade, tar spelarens nivå av Click Power och Rebirths och lägger till clickValue till spelarens Coins. Det finns ingenting i förfrågan som en fuskare skulle kunna ändra.

Robloxs säkerhetsguide säger att du aldrig ska förlita dig enbart på en frekvensgräns på klienten, och att dela ut valuta står bland de handlingar som ska begränsas. Servern räknar varje spelares klick i fönster på en sekund: det första klicket öppnar ett fönster, och när 15 klick har räknats ignoreras resten tills en sekund har gått sedan fönstret började. Ett skript som anropar remoten i en loop får högst 15 räknade klick i varje fönster. För att tillåta snabbare eller långsammare klickande, ändra MAX_CLICKS_PER_SECOND i SimulatorConfig.

Uppgraderingar och rebirths

BuyUpgrade och Rebirth är RemoteFunctions, så knappen kan vänta på svaret och visa det. Varje hanterare tar priset från serverns kopia av SimulatorConfig, kontrollerar spelarens Coins och ändrar något först därefter. Den returnerar true eller false och ett meddelande, till exempel "You need 5 more coins.", som LocalScript visar på statusraden.

Mellan priskontrollen och ändringen väntar ingenting och ingenting lämnar över körningen (yield), så två förfrågningar från samma spelare kan inte båda klara kontrollen innan den första har tagit mynten. En rebirth sätter Coins till 0, Click Power till nivå 1 och lägger till 1 till Rebirths, och klickformeln gör om det till multiplikatorn Rebirths + 1.

Reglaget SAVE_PROGRESS

Med SAVE_PROGRESS = false börjar varje spelare med 0 mynt vid varje besök, och det är vad du vill ha medan du bygger spelet. Steg 4 slår på det. Då väntar skriptet tills modulen PlayerData har laddat varje spelare och arbetar direkt med samma tabell som modulen sparar, så varje mynt och varje rebirth sparas utan extra kod.

Steg 3: bygg knapparna

Det här LocalScript bygger hela skärmen i kod: en mynträknare högst upp, en stor Click-knapp i mitten, knapparna Upgrade och Rebirth längst ner och en statusrad för serverns svar. Själv ändrar det aldrig ett enda tal.

  1. I Explorer, fäll ut StarterPlayer, håll muspekaren över StarterPlayerScripts och infoga ett LocalScript med namnet SimulatorClient.
  2. Ersätt innehållet med koden nedan och tryck på Play.
LocalScript i StarterPlayerScripts med namnet SimulatorClient
-- Bygger simulatorns knappar och visar serverns tal. Själv ändrar 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 förblir kvadratisk, anpassad efter skärmen och inte större än 200 gånger 200,
-- så att den på en telefon får plats mellan mynträknaren och knapparna längst ner
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 dyker upp över knappen. Talet är bara en gissning för utseendets skull;
-- vad klicket faktiskt är värt bestämmer servern.
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)

Knapparna använder Activated, som Roblox utlöser vid ett vänsterklick med musen på en dator, vid en tryckning på en telefon och när man trycker på A (eller kryss) på en handkontroll i UI-navigeringsläget.

På en handkontroll trycker A bara på den valda knappen. När GuiService.AutoSelectGuiEnabled är påslaget väljer knappen Select på handkontrollen dina knappar på skärmen; sedan kan spelarna gå mellan dem och trycka på A. Om du vill att en knapp på handkontrollen ska klicka direkt, koppla den via ContextActionService och anropa samma remote Click därifrån.

Fyra detaljer i skriptet:

  • Click-knappen skalas efter skärmen. Dess storlek är en andel av skärmen, UIAspectRatioConstraint håller den kvadratisk och UISizeConstraint begränsar den till 200 gånger 200 pixlar. På en skärm är den 200 pixlar bred; på en telefon krymper den och får plats mellan mynträknaren och knapparna längst ner. Om du flyttar delar, håll den borta från dem: Rebirth har ingen bekräftelse, så en oavsiktlig tryckning kan nollställa spelarens mynt och uppgraderingar.
  • "+N" som dyker upp är bara för utseendets skull. Det använder klientens kopia av formeln. Om servern ignorerar ett klick på grund av frekvensgränsen dyker "+N" ändå upp, men mynten ändras inte.
  • short() gör stora tal läsbara. 1 234 visas som 1.2K och 5 600 000 som 5.6M. Funktionen avrundar nedåt, så räknaren visar aldrig mer än du har. För tal större än T (biljoner) lägger du till poster i UNITS.
  • Skärmen uppdateras via event. Den lyssnar på värdena Coins och Rebirths och attributet PowerLevel, så priserna på knapparna stämmer hur talen än ändras.

ScreenGui har ResetOnSpawn satt till false, så den finns kvar när karaktären respawnar. Det spelar roll här: ett LocalScript i StarterPlayerScripts kopieras till spelaren en gång, när hen går in, så det skulle inte bygga skärmen igen.

Steg 4: spara framstegen med PlayerData

Än så länge nollställs allt när spelaren lämnar. I stället för ett andra sparskript kopplar sig simulatorn till modulen PlayerData från guiden om DataStore. Den modulen försöker redan igen med misslyckade förfrågningar, sparar automatiskt var 180:e sekund, sparar när spelaren lämnar och när servern stängs av och sparar aldrig en spelare vars data inte laddades.

  1. Gå igenom steg 1 i guiden om DataStore för att lägga till ModuleScript PlayerData i ServerScriptService. För att testa sparande i Studio, slå på Studios åtkomst till API-tjänster i en testkopia av spelet, som dess första avsnitt förklarar. SimulatorService kopplar själv in modulen med require, så skriptet Main från guiden behövs inte här.
  2. I PlayerData, lägg till PowerLevel = 1, och Rebirths = 0, i tabellen DEFAULTS, bredvid Coins = 0,.
  3. I samma modul, lägg till PowerLevel: number, och Rebirths: number, i typen Data, så att den strikta typkontrollen känner till de nya fälten.
  4. I SimulatorService, ersätt local SAVE_PROGRESS = false med local SAVE_PROGRESS = true.

Spelare som sparades innan du lade till fälten får dem automatiskt: funktionen migrate i PlayerData fyller i alla fält från DEFAULTS som saknas i den sparade tabellen, så de börjar med Click Power nivå 1 och 0 rebirths och behåller sina Coins. Om du hoppar över punkt 2 skriver SimulatorService ut en varning med fälten som ska läggas till och startar inte spelaren.

Varför simulatorn skriver till tabellen i PlayerData

När sparande är påslaget kopierar SimulatorService inte talen någonstans. PlayerData.Get(player) returnerar den levande tabell som modulen sparar, och simulatorn ändrar Coins, PowerLevel och Rebirths i just den tabellen. Varje tal har en enda kopia, och ett enda skript skriver till data store. Två skript som sparar samma nyckel skriver över varandra, och ett av dem kan spara gamla tal ovanpå det andras.

Gör inte också leaderstats i hanteraren Loaded, som guiden om DataStore rekommenderar för andra spel: SimulatorService gör redan Coins och Rebirths från den laddade tabellen. Om ett topplisteskript redan gör leaderstats, ta bort det.

Varför inte spara vid varje klick

Roblox tillåter varje server 60 + 40 × spelare skrivningar till en vanlig data store per minut (resten finns i tabellen över gränser i guiden om DataStore). Att spara vid varje klick med 15 klick per sekund är 900 skrivningar per minut för en enda spelare, långt mer än de 100 som en server med en spelare får. Att spara hela tabellen var 180:e sekund, när spelaren lämnar och när servern stängs av kostar bara några få skrivningar per spelare, och vid en krasch förloras högst framstegen sedan senaste automatiska sparning.

Om laddningen misslyckas låter modulen spelaren spela med nya tal men sparar dem aldrig, så en dålig laddning kan inte skriva över verkliga framsteg. Guiden förklarar hur modulen hanterar det.

Varför servern bestämmer varje tal

Exploiters styr sin egen enhet. Robloxs säkerhetsguide säger att de kan ändra vad som helst i sin lokala kopia av spelet och anropa vilken RemoteEvent eller RemoteFunction som helst hur många gånger som helst med vilka argument som helst. Simulatorns ekonomi är skyddad precis så mycket som dess serverskript är skyddat.

Vad en exploiter kan försöka och vad SimulatorService gör
Exploitern försökerOm klienten bestämdeVad SimulatorService gör
Anropa Click i en loop så snabbt som möjligtOändligt med myntRäknar högst 15 klick i varje sekundfönster och ignorerar resten.
Skicka ett antal mynt tillsammans med klicketVäljer sin egen belöningIgnorerar alla argument. Klickets värde tas från serverns tal.
Köpa en uppgradering eller rebirth utan tillräckligt med myntGratis uppgraderingarJämför priset med Coins på servern och svarar "You need N more coins."
Ändra Coins i leaderstats på sin skärmSpendera mynt som hen inte harLäser aldrig leaderstats. Den skriver bara dit från sin tabell.
Sätta attributet PowerLevel på sin PlayerEtt starkare klickLäser aldrig det attributet, och ändringen stannar på spelarens enhet.
Anropa Rebirth två gånger i samma ögonblickTvå rebirths för priset av enKontrollerar priset på nytt vid varje anrop, och mellan kontrollen och ändringen lämnar ingenting över körningen.
Ändra priserna i sin kopia av SimulatorConfigBilligare uppgraderingarAnvänder sin egen kopia av modulen.

Regeln gäller för varje remote i simulatorn: skicka vad spelaren vill göra, inte vad det är värt. I guiden om RemoteEvent går vi igenom kontroll av remote-argument mer ingående.

Vad du ska undvika i kopierade clickerskript

Vanliga knep från gamla clickerguider och vad den här guiden gör i stället
KnepProblemDen här guiden
Ett LocalScript lägger till mynt med leaderstats.Coins.Value += 1Ändringen stannar på en enda enhet, och den enheten styrs av exploiternServern lägger till mynten
clickEvent:FireServer(amount)Klienten väljer sin egen belöningClick skickar inga argument
Ingen frekvensgräns på servernRobloxs dokumentation säger att du aldrig ska förlita dig enbart på en gräns på klientenHögst 15 klick i varje sekundfönster
SetAsync vid varje klick eller uppgraderingÄter upp serverns gräns för skrivningarPlayerData sparar var 180:e sekund, när spelaren lämnar och vid avstängning. Spara direkt med PlayerData.SaveNow bara efter något som inte får gå förlorat, till exempel ett köp för Robux.
Ett andra data store-skript bara för simulatornTvå skript som sparar samma nyckel skriver över varandraSkriver till tabellen i PlayerData
Loopar med while wait(1) do för passiv inkomstRoblox märker den globala wait som föråldrad, ersatt av task.waittask.wait (se Så bygger du ut)
MouseButton1Click på knapparBeskriven för musklickActivated, för mus, tryckningar och handkontroll

Steg 5: testa

Gå igenom punkt 1 till 8 med SAVE_PROGRESS = false i SimulatorService, så att varje speltest börjar med nya tal. Om du redan har slagit på sparande i steg 4, sätt det till false så länge och sätt tillbaka true för punkt 9.

  1. Tryck på Play. Högst upp på skärmen står det 0 coins, på den gröna knappen Upgrade: 10 och på den orange Rebirth: 1.0K.
  2. Tryck på den lila knappen Click! tio gånger. Varje klick visar ett guldfärgat +1, och Coins i spelarlistan växer med 1.
  3. Tryck på Upgrade. Mynten går tillbaka till 0, statusraden blir grön med texten "Click Power is now level 2.", och på knappen står det nu Upgrade: 15. Från och med nu ger varje klick 2 mynt.
  4. Tryck på Rebirth utan att klicka. Statusraden skriver "You need 1000 more coins to rebirth.", och ingenting ändras.
  5. För att testa en rebirth utan 1 000 klick, stoppa testet, ändra Coins = 0 till Coins = 1000 på raden nära slutet av SimulatorService som startar nya spelare och tryck på Play. Tryck på Rebirth: Coins blir 0, Rebirths i spelarlistan blir 1, statusraden skriver "Rebirth 1! Every click is now worth x2.", och på knappen står det nu Rebirth: 3.0K. Varje klick ger nu 2 mynt på Click Power nivå 1. Sätt sedan tillbaka raden till 0.
  6. För att se frekvensgränsen, sätt MAX_CLICKS_PER_SECOND i SimulatorConfig till 2 och klicka snabbt. "+N" fortsätter att dyka upp, men Coins växer högst med värdet av 2 klick per sekund. Sätt tillbaka 15.
  7. Välj en telefon i Device Simulator i Studio (det är en Studio-beta; den gamla Device Emulator fungerar också) och tryck på Play. Kontrollera att Click-knappen inte går in över mynträknaren eller knapparna Upgrade och Rebirth, och att statusraden syns och inte täcks av knappen när du trycker på Upgrade.
  8. Anslut en handkontroll eller öppna Controller Emulator i Studio (Controller på fliken Emulation) under ett speltest, tryck på Select och kontrollera att du kan nå alla tre knapparna och trycka på dem med A.
  9. Med sparande påslaget (steg 4) och SAVE_PROGRESS = true igen, tjäna några mynt, tryck på Stop och sedan på Play igen. Dina Coins, din nivå av Click Power och dina Rebirths kommer tillbaka.

Gör en gym- eller gruvsimulator

Många simulatorer byter ut knappen mot en handling i världen: lyfta en hantel, svinga en hacka, svinga ett svärd i luften. Under det är det samma klick. Ett Tool kan anropa samma remote Click, så SimulatorService, dess priser och dess frekvensgräns stannar som de är.

  1. I Explorer, håll muspekaren över StarterPack, infoga ett Tool och döp det till Dumbbell. Infoga en Part med namnet Handle i det, ge den formen av en hantel och kryssa ur Anchored, som i stegen med Tool i svärdsguiden.
  2. Infoga ett LocalScript med namnet LiftClient i Tool och klistra in koden nedan.
  3. Tryck på Play, ta hanteln och klicka. Mynten växer med din Click Power för varje lyft, precis som med knappen.
LocalScript i Tool Dumbbell i StarterPack med namnet LiftClient
-- LocalScript inuti Tool Dumbbell, med namnet LiftClient.
-- Varje lyft är ett klick: det anropar samma remote Click som knappen, och servern
-- bestämmer vad det är värt och hur många lyft som räknas.

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 mellan lyft på den här enheten; servern har sin egen gräns
local LIFT_ANIMATION_ID = "" -- valfritt: "rbxassetid://" följt av id för din animation

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

-- Laddar lyftanimationen en gång per karaktär, 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() -- inga argument: servern räknar ut belöningen
end)

För en lyftanimation, gör den i Animation Editor med prioriteten Action, publicera den och klistra in dess ID i LIFT_ANIMATION_ID. Stegen med animation i svärdsguiden fungerar på samma sätt.

  • Anpassa serverns gräns efter handlingen. LIFT_SECONDS bromsar bara ärliga spelare: en fuskare kan anropa Click från sin egen kod. Om lyft är det enda sättet att tjäna, sänk MAX_CLICKS_PER_SECOND i SimulatorConfig till det verkliga tempot, till exempel till 2 för ett lyft var 0.5:e sekund, så att ett skript inte kan tjäna mer än en spelare. Räkna sedan om tempotabellen: varje tid i den bygger på 5 klick per sekund.
  • Behåll eller dölj knappen. Click-knappen fortsätter att fungera bredvid Tool. För att dölja den, lägg till clickButton.Visible = false direkt efter raden i SimulatorClient som skapar clickButton.
  • Intjäning bara på rätt ställe. För att bara betala i gymmet eller i gruvan, kontrollera på servern var karaktären befinner sig innan klicket räknas, till exempel via avståndet till en part i det området. En kontroll i LiftClient skulle inte stoppa någon.

Vad du ska göra sedan: byggordningen för en simulator

En simulator är en stapel av system ovanpå den här loopen. Bygg dem i den här ordningen, så att varje system har något att multiplicera, och gör ett speltest efter varje. Här är ordningen som vi rekommenderar, med en guide för varje steg.

Byggordningen för en simulator i Roblox, från grundloopen och utåt
OrdningSystemGuideVarför just nu
1Intjäning, uppgradering, rebirthDen här guidenAllt annat multiplicerar den här loopen, så justera först dess tal med tempotabellen.
2SparandeGuiden om DataStore, sedan steg 4Framsteg som nollställs när man går in igen dödar en simulator. Lägg till det före allt som spelarna kan förlora.
3Ägg och pets som multiplikatorerKläcka ägg och pets som följer spelarenEtt andra mål bredvid mynten: något att samla som gör varje klick mer värt.
4Zoner bakom rebirthsSå bygger du utNågonstans att gå efter en rebirth, med bättre belöningar som servern kontrollerar.
5TopplistorGuiden om topplistorEn global topp 10 för rebirths ger den långa klättringen en mening.
6Dagliga belöningar och koderDagliga belöningar och koderAnledningar att komma tillbaka i morgon och efter varje uppdatering.
7Game passesGuiden om game passes2x mynt, autoklick eller en extra plats för pets, med kontroll på servern. Sälj dem när den kostnadsfria loopen redan är rolig.

För skärmarna innehåller de kostnadsfria UI-kiten för Roblox skärmar i simulatorstil tillsammans med skripten som får dem att fungera.

Så gör du en simulator utan att skriva skript

En simulator behöver ändå skript: något måste lägga till mynt, kontrollera priser och spara. Du behöver inte skriva dem själv:

  • Ett simulatorkit från Creator Store. Läs dess skript innan du publicerar och kontrollera att mynten bara ändras i ett Script på servern, inte i ett LocalScript.
  • Ett plugin som genererar simulatorer. Samma kontroll för allt som det skapar.
  • En AI-agent i Studio, till exempel RoCode, som kan bygga samma tre skript i din öppna place.
  • Build i Robloxs mobilapp. Enligt Robloxs dokumentation gör den enklare spel i 2D och 2.5D från en beskrivning, till exempel clickers, och släpps gradvis region för region.

Vad du än väljer, kör kontrollerna från steg 5 och kontrollerna mot exploits från avsnittet Varför servern bestämmer varje tal på resultatet.

Så bygger du ut: pets, zoner, autoklick och topplistor

Pets som multiplikatorer

En vanlig variant: varje pet är en multiplikator. Spara en lista med id för spelarens pets i spelarens sparade tabell, och låt servern multiplicera clickValue med bonusen för varje utrustat pet. Kläck ägg på servern: klienten ber om att öppna ett ägg, servern kontrollerar och tar priset och väljer sedan ett pet med ett viktat slumpmässigt kast. Låt aldrig klienten slå för ett ägg eller säga vilket pet som kom. Guiden om inventarier visar hur du lagrar, sparar och visar spelarens föremål, och pets fungerar likadant. Guiden om att kläcka ägg bygger kastet på servern, och guiden om pets får pets att sväva bredvid sin ägare.

Zoner som låses upp med rebirths

En zon är en del av kartan med bättre belöningar bakom en spärr. Lås belöningen, inte bara dörren: allt som betalar inuti zonen måste kontrollera spelarens Rebirths i serverns tabell innan det betalar. En dörr som ett LocalScript öppnar för behöriga spelare duger för utseendets skull, men exploiters kan ändra parts och flytta sin karaktär på sin enhet.

Autoklick som game pass

En autoclicker som säljs som game pass måste köras på servern. Flytta innehållet i Click-hanteraren till en funktion, till exempel addClick(player), koppla remoten till den, och för passets ägare, anropa den från en serverloop med task.wait(0.5), inte med den föråldrade wait. Då går autoklick mot samma gräns per sekund som vanliga klick. Kontrollera ägandet på servern med MarketplaceService:UserOwnsGamePassAsync, som guiden om game passes gör för sina bonusar. Ett pass för 2x mynt fungerar likadant: multiplicera clickValue på servern för ägarna. Innan du sätter ett pris visar den kostnadsfria Robux-skattekalkylatorn hur mycket varje försäljning ger dig efter Robloxs andel, och DevEx-kalkylatorn visar hur mycket de Robux är värda i amerikanska dollar.

Global topp 10 för rebirths

leaderstats jämför bara spelare på samma server. För att ranka alla spelares Rebirths, skriv dem till ett ordnat datalager (ordered data store) och läs tillbaka de översta posterna, som i steg 4 i guiden om topplistor. Ordnade datalager tillåter färre skrivningar än vanliga, 30 + 5 × spelare per minut och server, så skriv när spelaren lämnar och med en timer.

Mycket stora tal

Tal i Luau är doubles, de håller ungefär 15 värdesiffror. IntValue lagrar heltal upp till ungefär 9.2 triljoner, men Roblox varnar för att värden större än 2^53 (ungefär 9 biljarder) förlorar precision i skript. Med de här inställningarna passerar rebirthpriset den gränsen vid den 29:e rebirthen. Om ditt spel går längre, byt leaderstats-värdena till NumberValue (ersätt IntValue i båda skripten), som lagrar mycket större tal med samma precision på ungefär 15 siffror, och lägg till suffix i short().

Vad ett simulatorspel vilar på

En simulator är ett spel om tal. Klicket, uppgraderingen och rebirthen ovan är hela loopen; om spelarna stannar avgörs av hur de talen växer. Med några minuters mellanrum ska spelaren ha råd med något som snabbar upp de följande minuterna, och varje session ska sluta nära ett mål som man vill komma tillbaka för.

  • Tillväxt som räcker länge. Uppgraderingspriserna växer snabbare än inkomsten, så varje steg tar lite längre tid. En rebirth nollställer mynten för en permanent multiplikator, så det gamla området går snabbt och klättringen känns ny.
  • Något att samla. Zoner att låsa upp, pets från ägg som multiplicerar intjäningen och verktyg att uppgradera ger spelarna en lista med mål utöver ett enda tal.
  • Stora tal som förblir läsbara. Visa 1.5M, inte 1500000, och lagra talen så att servern kan jämföra dem även när de blir stora.

Intäkter som passar en simulator

Vanliga pass multiplicerar mynt, ger en extra plats för pets, öppnar fler ägg åt gången eller slår på autoklick. Sälj dem som game passes och kontrollera dem på servern. Myntpaket är developer products. Om ägg eller något annat med slumpmässigt resultat kan köpas för Robux eller för valuta som köpts för Robux kräver Roblox att oddsen visas före köpet: läs paid random items (på engelska) innan du bygger butiken.

Vad som får spelare att komma tillbaka

Sparade framsteg, en ny zon eller en uppsättning pets i uppdateringarna, dagliga belöningar, koder som tillkännages tillsammans med uppdateringar och en topplista för rebirths. Andra genrer, var och en med sin loop, sina system och sin byggplan: spelgenrer i Roblox.

Vanliga fel och lösningar

Öppna Output-fönstret (menyn Window, sedan Output) innan du trycker på Play. De flesta problem skriver ut en varning eller ett fel där med skriptets namn och raden.

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

LocalScript väntar på de remotes som SimulatorService skapar vid start. Kontrollera att SimulatorService är ett Script, inte ett LocalScript, att det ligger i ServerScriptService och att Output inte har något fel från det. Samma varning för SimulatorConfig betyder att modulen inte finns i ReplicatedStorage eller har ett annat namn.

Knapparna dyker aldrig upp

LocalScript väntar på dina leaderstats innan skärmen byggs. Om Output säger Infinite yield possible på leaderstats har SimulatorService inte startat dig ännu. Med SAVE_PROGRESS = true väntar det på PlayerData, så kontrollera att PlayerData ligger i ServerScriptService och laddas utan fel.

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

Sparande är påslaget, men modulen PlayerData har inte de nya fälten än. Lägg till dem i dess DEFAULTS, som i steg 4, och tryck på Play igen.

"+1" dyker upp, men mynten växer inte

Servern räknar inte klicken. Antingen finns det ett fel i SimulatorService (leta efter röd text från det i Output), eller så kommer klicken snabbare än MAX_CLICKS_PER_SECOND tillåter. Om spelare når gränsen när de spelar normalt, höj den i SimulatorConfig.

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

Anropet till BuyUpgrade eller Rebirth kraschade i stället för att returnera ett svar. Den vanliga orsaken är ett fel inuti SimulatorService medan förfrågan hanterades, så leta efter ett rött fel från det i Output: där anges raden.

Mynträknaren på skärmen och spelarlistan visar olika tal

Ett annat skript gör också en leaderstats-mapp, så varje spelare har två, och LocalScript kan läsa den andra. Ta bort det extra skriptet: SimulatorService gör Coins och Rebirths själv.

Mynten nollställs varje gång jag går in igen

Sparande är avstängt. Gå igenom steg 4. Om det är påslaget och mynten ändå nollställs i Studio, kontrollera att Studios åtkomst till API-tjänster är påslagen i testkopian, som guiden om DataStore förklarar.

Gör det med RoCode

Om du inte vill klistra in det här för hand kan RoCode bygga det i din öppna place. Det är en oberoende AI-agent för kod, inte från Roblox: du beskriver systemet i dess webbchatt, och dess plugin för Roblox Studio skapar skripten i din Explorer, så du behöver inte kopiera kod från ett chattfönster.

Du skriver

Gör en clicker-simulator: en stor Click-knapp som ger mynt lika med min nivå av Click Power gånger (rebirths + 1), en Upgrade-knapp som kostar 10 mynt och blir 1.5 gånger dyrare för varje nivå, och en Rebirth-knapp för 1 000 mynt som nollställer mynt och uppgraderingar. Håll talen på servern och begränsa klicken till 15 per sekund. Jag har redan en modul PlayerData.

RoCode gör
  • Kan först läsa din modul PlayerData och alla leaderstats-skript med Search Scripts och Read Script, för att lägga till fält i dina befintliga data i stället för att skriva ett andra sparskript
  • Kan göra ett utkast till skärmen med HUD-layouten i Build UI (med plugin 3.9 eller nyare, i simulatorstil) eller bygga knapparna i ett LocalScript, och skriver ModuleScript, serverns Script och LocalScript med Create Script
  • Den är instruerad att kontrollera att varje skript som den skriver kompilerar med Check Script, som kompilerar det i Studio utan att köra det
  • Sätter en ångrapunkt före och efter varje omgång ändringar, så Ctrl+Z backar en omgång i taget

RoCode kan inte skapa game passes och developer products eller ladda upp meshar och ikoner för pets: det görs i Creator Hub och Studio. Med plugin 3.9.11 eller nyare kan RoCode köra ett speltest av ditt spel i Studio och styra en testkaraktär för att kontrollera att allt fungerar, och med plugin 3.9.15 eller nyare kan testkaraktären trycka på knappar på skärmen, till exempel trycka på Click och kontrollera att Coins växte. Den bestämmer själv när den kör ett speltest, upp till 2 per bygge plus 1 för att kontrollera sin rättning, och kontrollerar bara det som den har valt, så testa loopen själv. En hel simulator är flera prompter, ett system i taget: så bygger du med RoCode ett system per prompt. Så ansluter RoCode till Studio.

Vanliga frågor

Hur gör man en simulator i Roblox utan skript?

En fungerande simulator behöver skript: något måste lägga till mynt, kontrollera priser och spara framstegen. Du kan klistra in de tre skripten från den här guiden som de är och bara ändra talen i SimulatorConfig, eller låta ett kit från Creator Store, ett plugin eller en AI-agent göra dem och kontrollera att servern bestämmer över mynten. Alternativen.

Hur fungerar ett rebirthsystem?

En rebirth byter dina mynt och uppgraderingar mot en permanent bonus. I den här guiden kostar den första rebirthen 1 000 mynt; den sätter Coins till 0, Click Power till nivå 1 och lägger till 1 till Rebirths, och därefter multipliceras varje klick med Rebirths + 1. Varje rebirth kostar tre gånger mer än den förra.

Hur gör man en styrke- eller gymsimulator?

Ge spelarna ett Tool, till exempel en hantel, vars LocalScript anropar samma remote Click vid Tool.Activated. Servern räknar ut belöningen precis som för ett klick på knappen. Sänk serverns klickgräns till lyfttempot, så att ett skript inte kan tjäna mer än en spelare. Skriptet finns i avsnittet versionen med hantel.

Vilka system behövs i en simulator?

Först loopen med intjäning, uppgraderingar och rebirths, sedan sparande, sedan pets eller en annan samling som multiplicerar intjäningen, zoner bakom rebirths, topplistor, dagliga belöningar och koder, och allra sist game passes. Byggordningen har en guide för vart och ett.

Hur lång tid ska en rebirth ta?

Tillräckligt länge för att spelarna först ska köpa några uppgraderingar, och tillräckligt kort för att de ska nå en under första sessionen. Med talen i den här guiden kommer den första rebirthen efter ungefär 1.2 minuter vid 5 klick per sekund; höjer du REBIRTH_BASE_COST till 10 000 blir det ungefär 8 minuter. Fler inställningar i tempotabellen.

Hur skyddar man sig mot autoclickers?

Servern räknar högst 15 klick per spelare i varje sekundfönster och ignorerar resten. Under den gränsen ser ett skript ut precis som en snabb spelare, så det är just gränsen som skyddar ekonomin. Du kan också sälja autoklick som ett game pass som körs på servern.

Varför nollställs mynten när man går in igen?

Ingenting sparar dem än. Lägg till modulen PlayerData från guiden om DataStore, lägg till PowerLevel och Rebirths i dess DEFAULTS och sätt SAVE_PROGRESS = true i SimulatorService, som i steg 4.

Hur lägger man till pets i en simulator?

Gör varje pet till en multiplikator som servern tillämpar på klicken. Kläck ägg på servern med ett viktat slumpmässigt val, spara id för spelarens pets tillsammans med resten av spelarens data och visa dem i ett inventarie-GUI, som i guiden om inventarier.

Vad är bättre: att klicka på en part eller på en knapp?

Båda fungerar. En knapp på skärmen är bekväm på telefoner, och en part med ClickDetector passar ett spel där allt händer i världen. Enligt Robloxs dokumentation kontrollerar servern inte ClickDetector-event alls, så begränsa frekvensen för de klicken på servern på samma sätt.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.