Tutorial · Spielsysteme

Wie du ein Simulator-Spiel in Roblox erstellst

Die meisten Simulator-Spiele laufen in derselben Schleife: Du machst etwas Einfaches, um eine Währung zu verdienen, gibst sie für Upgrades aus, die schneller verdienen, und machst dann einen Rebirth, um mit einem dauerhaften Multiplikator neu anzufangen. Dieser Guide baut diese Schleife als Clicker aus drei Skripten, bei denen der Server jede Zahl entscheidet, und speichert sie mit dem PlayerData-Modul aus dem DataStore-Tutorial. Wenn du noch nie ein Spiel in Studio gebaut hast, bau zuerst einen kurzen Coin-Parcours.

Aktualisiert am 14. November 202625 Min. LesezeitGeschrieben von

Kurz gesagt

Ein Roblox-Simulator ist eine Schleife: klicken, um Coins zu verdienen, sie für Upgrades ausgeben, die schneller verdienen, dann ein Rebirth für einen dauerhaften Multiplikator. Leg die Preise in ein ModuleScript in ReplicatedStorage. Lass ein Script in ServerScriptService die Coins, Click Power und Rebirths jedes Spielers besitzen, höchstens 15 Klicks pro Sekunde von einem Click-RemoteEvent zählen und Upgrades und Rebirths über RemoteFunctions verkaufen, nachdem es den Preis geprüft hat. Ein LocalScript zeigt die Buttons Click, Upgrade und Rebirth. Mit den Zahlen aus diesem Guide erreicht ein Spieler, der 5-mal pro Sekunde klickt, den ersten Rebirth nach etwa 1,2 Minuten, und die Tempo-Tabelle zeigt, was du für einen längeren Aufstieg ändern musst.

  • Ein Klick schickt nichts außer dem Klick. Der Server berechnet, was er wert ist, also kann sich ein manipulierter Client keine Coins geben.
  • Speichere die ganze Tabelle per Timer und wenn Spieler gehen, nie bei jedem Klick. Roblox erlaubt jedem Server 60 + 40 × Spieler Data-Store-Schreibvorgänge pro Minute.
  • Kein Scripting? Ein Kit aus dem Creator Store, ein Plugin oder ein KI-Agent kann dieselbe Schleife bauen. Prüf, ob der Server über die Coins entscheidet: die Möglichkeiten.
  • Lieber Gewichtheben oder Bergbau statt eines Buttons? Ein Tool kann dasselbe Click-Remote feuern: die Version zum Gewichtheben. Dann füg Systeme in der Bau-Reihenfolge unten hinzu.
Auf dieser Seite
  1. So funktioniert es
  2. 1. Config-Modul
  3. 2. Server-Skript
  4. 3. Buttons
  5. 4. Fortschritt speichern
  6. Warum der Server entscheidet
  7. 5. Testen
  8. Version zum Gewichtheben
  9. Bau-Reihenfolge
  10. Ohne Scripting
  11. Erweitern
  12. Das Genre
  13. Häufige Fehler
  14. Mit RoCode
  15. Häufige Fragen
  16. Quellen und weiterführende Links

So funktioniert die Kernschleife eines Simulators

IllustrationDer Spieler kauft Click Power Stufe 2 für 10 Coins, erreicht dann (beschleunigt) 1.000 Coins und macht einen Rebirth: Coins und Upgrades werden zurückgesetzt, und jeder Klick ist x2 wert.

Ein Simulator ist eine Schleife aus drei Aktionen. Der Spieler macht immer wieder etwas Einfaches, um eine Währung zu verdienen, gibt sie für Upgrades aus, die schneller verdienen, und wenn die Upgrades teuer werden, macht er einen Rebirth: Er gibt seine Coins und Upgrades für einen Bonus auf, der nie verschwindet, und steigt dann schneller wieder auf. Andere Simulatoren ersetzen den Klick durch Gewichtheben, Bergbau oder Sammeln, aber die Schleife darunter ist dieselbe.

Die drei Aktionen in der Schleife dieses Guides
AktionWas sie kostetWas sie bringtWer entscheidet
ClickNichtsCoins in Höhe von Click Power × (Rebirths + 1)Der Server, der in jedem Sekundenfenster höchstens 15 Klicks zählt
Upgrade10 Coins, dann für jede Stufe das 1,5-Fache des letzten PreisesEine Click-Power-Stufe mehr, bis Stufe 50Der Server, mit seiner eigenen Kopie der Preise
Rebirth1.000 Coins, dann für jeden Rebirth das 3-Fache des letzten PreisesCoins zurück auf 0 und Click Power zurück auf Stufe 1, dazu dauerhaft +1 auf den MultiplikatorDer Server

Jede Zahl liegt auf dem Server. Das Gerät des Spielers zeichnet die Buttons und fragt nach Dingen ("ich habe geklickt", "ich will ein Upgrade"); der Server entscheidet, was das wert ist und ob es passieren darf. Clicker-Skripte, die ausgenutzt werden, fügen oft Coins in einem LocalScript hinzu oder lassen den Client schicken, wie viele Coins dazukommen.

Die Teile des Simulators
TeilWo es liegtWas es macht
ModuleScript SimulatorConfigReplicatedStoragePreise, Limits und die Formeln für den Wert eines Klicks, den Upgrade-Preis und den Rebirth-Preis. Beide Seiten lesen es.
Script SimulatorServiceServerScriptServiceHält die Zahlen jedes Spielers, verarbeitet Klicks, Upgrades und Rebirths und füllt leaderstats.
Folder SimulatorRemotesReplicatedStorage (SimulatorService erstellt ihn)Das RemoteEvent Click und die RemoteFunctions BuyUpgrade und Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsBaut die Buttons, schickt Klicks und Anfragen und zeigt die Zahlen des Servers.
ModuleScript PlayerData (optional)ServerScriptServiceSpeichert den Fortschritt zwischen Besuchen. Es kommt aus dem DataStore-Tutorial und wird nur für Schritt 4 gebraucht.
Der Explorer, während das Spiel läuft. SimulatorService erstellt SimulatorRemotes und die drei Remotes beim Spielstart, und PlayerData ist erst da, wenn du in Schritt 4 das Speichern hinzufügst.
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

Schritt 1: Preise und Formeln in ein Modul legen

Jede Zahl, die du vielleicht anpassen willst, kommt in ein ModuleScript: was ein Klick wert ist, was jedes Upgrade und jeder Rebirth kostet, und das Klick-Limit. Der Server entscheidet damit, und das LocalScript zeigt damit die Preise auf den Buttons, also ist eine Änderung eine Bearbeitung an einer Stelle.

  1. Fahr im Explorer mit der Maus über ReplicatedStorage, klick auf den Button + und füge ein ModuleScript ein.
  2. Benenn es in SimulatorConfig um (Groß- und Kleinschreibung zählt) und ersetz seinen Inhalt durch den Code unten.
ModuleScript in ReplicatedStorage namens SimulatorConfig
-- Alle Zahlen der Kernschleife und die Formeln, die beide Seiten nutzen. Der Client
-- nutzt sie nur, um Preise anzuzeigen; der Server entscheidet mit seiner eigenen Kopie.

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- Preis für Click Power Stufe 2
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- jede Stufe kostet das 1,5-Fache der letzten
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- Coins für den ersten Rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- jeder Rebirth kostet das 3-Fache des letzten
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- Klicks darüber werden in derselben Sekunde ignoriert

-- Coins pro Klick: die Click-Power-Stufe mal 1 + Anzahl der Rebirths
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Preis der nächsten Click-Power-Stufe
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- Coins für den nächsten Rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

Spieler können ein ModuleScript in ReplicatedStorage lesen, also sind diese Preise öffentlich. Das ist in Ordnung: Sie stehen sowieso auf den Buttons. Client und Server führen jeweils ihre eigene Kopie des Moduls aus, also ändert ein Spieler, der die Zahlen auf seinem Gerät bearbeitet, nichts auf dem Server.

Was die Formeln mit diesen Einstellungen ergeben
Click-Power-StufePreis der nächsten StufeCoins pro Klick, ohne RebirthCoins pro Klick, 1 Rebirth
11012
21524
32236
43348
550510

Rebirths kosten 1.000 Coins, dann 3.000, dann 9.000, weil rebirthCost den Preis jedes Mal mit 3 multipliziert. Nach einem Rebirth ist jeder Klick doppelt so viel wert, nach zwei Rebirths dreimal so viel, und so weiter.

Wie lange ein Rebirth mit diesen Zahlen dauert

Die Formeln entscheiden, wie lange die Schleife dauert, also lohnt es sich, die Zahlen auszurechnen, bevor die Spieler es tun. Die Tabelle nimmt einen Spieler an, der einen Rebirth macht, sobald er ihn bezahlen kann, und sonst die nächste Click-Power-Stufe kauft, sobald er sie bezahlen kann und sie weniger kostet als der Rebirth. Die Zeiten zählen ab einem frischen Start, also ist die letzte Spalte die Gesamtzeit bis zu 3 Rebirths.

Minuten ab einem frischen Start bis zu jedem Rebirth bei 5 Klicks pro Sekunde, nach REBIRTH_BASE_COST. Aus den Formeln von SimulatorConfig berechnet, nicht bei Spielern gemessen
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1.000 (dieser 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

Ohne Rebirths kommt Click Power Stufe 5 nach 34 Klicks, Stufe 10 nach 122 und Stufe 13 nach 285. Mit den Standardzahlen hört der Spieler dann mit den Upgrades auf, weil Stufe 14 1.297 Coins kostet, mehr als der Rebirth für 1.000 Coins, und der erste Rebirth kommt nach insgesamt 362 Klicks. Beim Server-Limit von 15 Klicks pro Sekunde teilst du jede Zeit durch 3. Ändere irgendeine Zahl in SimulatorConfig, und diese Zeiten ändern sich mit, also rechne sie neu aus.

Das Wachstum einstellen

Die beiden _GROWTH-Zahlen legen fest, wie schnell die Preise steigen. Bei 1,5 kostet jedes Upgrade die Hälfte mehr als das vorherige, während jede Stufe nur einen Coin pro Klick dazugibt (vor dem Rebirth-Multiplikator), also dauert es mit jeder neuen Stufe länger, bis sie sich bezahlt macht. Genau diese Verlangsamung macht einen Rebirth lohnend. Erhöh das Wachstum für einen längeren Aufstieg, senk es für einen schnelleren, und halt REBIRTH_BASE_COST hoch genug, dass Spieler vor ihrem ersten Rebirth ein paar Upgrades kaufen.

Für einen ersten Rebirth nach mehreren Minuten statt nach etwa einer erhöhst du REBIRTH_BASE_COST auf 5.000 oder 10.000.

Schritt 2: Das Server-Skript hinzufügen

Dieses Script besitzt jede Zahl. Es erstellt die Remotes, gibt jedem Spieler einen Ordner leaderstats mit Coins und Rebirths und beantwortet die drei Anfragen. Fahr mit der Maus über ServerScriptService, füge ein Script ein, benenn es in SimulatorService um und ersetz seinen Inhalt durch das hier:

Script in ServerScriptService namens SimulatorService
-- Besitzt alle Zahlen: Klicks bringen hier Coins, Upgrades und Rebirths werden hier gekauft,
-- und leaderstats zeigen nur das Ergebnis an.

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

-- false: alle fangen bei jedem Besuch neu an. true: mit dem PlayerData-Modul aus dem
-- DataStore-Tutorial laden und speichern (zuerst PowerLevel = 1 und Rebirths = 0 in DEFAULTS eintragen).
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 } = {} -- wann das aktuelle Sekundenfenster dieses Spielers begonnen hat
local clickCount: { [Player]: number } = {} -- in diesem Fenster gezählte Klicks

-- Kopiert die Zahlen des Servers in das, was Spieler sehen: leaderstats und ein 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

-- Startet einen Spieler mit den übergebenen Daten (neue Zahlen oder eine gespeicherte Tabelle)
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

-- Ein Klick enthält keine Zahlen: Der Server berechnet, was er wert ist
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 -- ein Autoclicker oder ein Skript, das das Remote in einer Schleife feuert
	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
	-- Ein Rebirth tauscht Coins und Upgrades gegen einen dauerhaften 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

-- Startzahlen: neue oder die Tabelle, die das PlayerData-Modul lädt und speichert
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) -- dieselbe Tabelle, die PlayerData speichert, also wird jede Änderung gespeichert
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- alle, deren Daten geladen wurden, bevor dieses Skript startete
	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 kommt beim Spieler als Attribut PowerLevel an seinem Player-Objekt an, nicht als dritter leaderstats-Wert, also zeigt die Spielerliste nur Coins und Rebirths. Attribute, die der Server setzt, werden auf das Gerät des Spielers repliziert; eine Änderung, die ein Spieler auf seinem eigenen Gerät macht, bleibt dort.

Klicks und das Ratenlimit

Das Click-Remote hat keine Argumente. Auf dem Server ist der erste Parameter eines OnServerEvent-Handlers immer der Spieler, der es gefeuert hat, also weiß der Server, wer geklickt hat, schaut seine Click-Power-Stufe und Rebirths nach und addiert clickValue zu seinen Coins. In der Anfrage gibt es nichts, was ein Cheater ändern könnte.

Der Sicherheitsguide von Roblox sagt, dass du dich nie nur auf ein Ratenlimit im Client verlassen sollst, und nennt das Vergeben von Währung unter den Aktionen, die begrenzt werden sollten. Der Server zählt die Klicks jedes Spielers in Fenstern von einer Sekunde: Der erste Klick startet ein Fenster, und sobald 15 Klicks gezählt sind, werden weitere ignoriert, bis seit dem Start des Fensters eine Sekunde vergangen ist. Ein Skript, das das Remote in einer Schleife feuert, bekommt in jedem Fenster höchstens 15 Klicks gezählt. Um schnelleres oder langsameres Klicken zu erlauben, ändere MAX_CLICKS_PER_SECOND in SimulatorConfig.

Upgrades und Rebirths

BuyUpgrade und Rebirth sind RemoteFunctions, also kann der Button auf die Antwort warten und sie anzeigen. Jeder Handler liest den Preis aus der Server-Kopie von SimulatorConfig, prüft die Coins des Spielers und ändert erst dann etwas. Er gibt true oder false zurück und eine Nachricht wie "You need 5 more coins.", die das LocalScript in einer Statuszeile zeigt.

Zwischen der Preisprüfung und der Änderung wartet oder yieldet nichts, also können zwei Anfragen desselben Spielers nicht beide die Prüfung bestehen, bevor die erste die Coins abzieht. Ein Rebirth setzt Coins auf 0 und Click Power auf Stufe 1 und addiert 1 zu Rebirths, was die Klick-Formel in einen Multiplikator von Rebirths + 1 verwandelt.

Der Schalter SAVE_PROGRESS

Mit SAVE_PROGRESS = false fängt jeder Spieler bei jedem Besuch bei 0 Coins an, und genau das willst du, während du baust. Schritt 4 schaltet es ein. Das Skript wartet dann, bis das PlayerData-Modul jeden Spieler geladen hat, und arbeitet direkt auf der Tabelle, die dieses Modul speichert, also wird jeder Coin und jeder Rebirth ohne zusätzlichen Code gespeichert.

Schritt 3: Die Buttons bauen

Dieses LocalScript baut den ganzen Bildschirm im Code: die Coin-Anzeige oben, einen großen Click-Button in der Mitte, die Buttons Upgrade und Rebirth unten und eine Statuszeile für die Antworten des Servers. Es ändert nie selbst eine Zahl.

  1. Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts und füge ein LocalScript namens SimulatorClient ein.
  2. Ersetz seinen Inhalt durch den Code unten und drück auf Play.
LocalScript in StarterPlayerScripts namens SimulatorClient
-- Baut die Simulator-Buttons und zeigt die Zahlen des Servers. Es ändert sie nie.

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))
-- Der Click-Button bleibt quadratisch, passt sich dem Bildschirm an und wird nie größer als 200 mal 200,
-- damit er auf dem Handy zwischen die Coin-Anzeige und die Buttons unten passt
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()

-- Ein "+N", das vom Button nach oben schwebt. Die Zahl ist nur eine Schätzung für die Anzeige;
-- der Server entscheidet, was der Klick wirklich wert ist.
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)

Die Buttons nutzen Activated, das Roblox bei einem Linksklick am Desktop, einem Tippen auf dem Handy und bei A (oder Kreuz) auf einem Controller im UI-Navigationsmodus feuert.

Auf einem Controller drückt A nur einen Button, der ausgewählt ist. Wenn GuiService.AutoSelectGuiEnabled an ist, wählt die Select-Taste des Gamepads deine Buttons auf dem Bildschirm aus; Spieler können dann zwischen ihnen wechseln und A drücken. Wenn eine Controller-Taste lieber direkt klicken soll, binde eine mit ContextActionService und feuere von dort dasselbe Click-Remote.

Vier Details im Skript:

  • Der Click-Button passt sich dem Bildschirm an. Seine Größe ist ein Anteil des Bildschirms, ein UIAspectRatioConstraint hält ihn quadratisch, und ein UISizeConstraint begrenzt ihn auf 200 mal 200 Pixel. Auf einem Monitor ist er 200 Pixel breit; auf einem Handy schrumpft er, damit er zwischen die Coin-Anzeige und die Buttons unten passt. Halt ihn von ihnen fern, wenn du Dinge verschiebst: Rebirth hat keine Bestätigung, also kann ein versehentliches Tippen dort die Coins und Upgrades des Spielers zurücksetzen.
  • Das "+N" ist nur Anzeige. Es nutzt die Kopie der Formel im Client. Ignoriert der Server einen Klick wegen des Ratenlimits, erscheint das "+N" trotzdem, aber die Coins ändern sich nicht.
  • short() hält große Zahlen lesbar. 1.234 wird als 1.2K angezeigt und 5.600.000 als 5.6M. Es rundet ab, also zeigt die Coin-Anzeige nie mehr, als du hast. Füg Einträge zu UNITS hinzu für Zahlen über T (Billionen).
  • Der Bildschirm aktualisiert sich über Events. Er hört auf die Werte Coins und Rebirths und das Attribut PowerLevel, also stimmen die Preise auf den Buttons, egal wie sich die Zahlen ändern.

Bei der ScreenGui ist ResetOnSpawn auf false gesetzt, also bleibt sie, wenn die Figur neu spawnt. Das ist hier wichtig: Ein LocalScript in StarterPlayerScripts wird nur einmal zum Spieler kopiert, wenn er beitritt, also würde es den Bildschirm nicht noch einmal bauen.

Schritt 4: Fortschritt mit PlayerData speichern

Bisher wird alles zurückgesetzt, wenn ein Spieler geht. Statt ein zweites Speicher-Skript hinzuzufügen, hängt sich der Simulator an das PlayerData-Modul aus dem DataStore-Tutorial. Dieses Modul wiederholt schon fehlgeschlagene Anfragen, speichert automatisch alle 180 Sekunden, speichert, wenn ein Spieler geht und wenn der Server herunterfährt, und speichert nie einen Spieler, dessen Daten nicht geladen werden konnten.

  1. Folge Schritt 1 des DataStore-Tutorials, um das ModuleScript PlayerData zu ServerScriptService hinzuzufügen. Um das Speichern in Studio zu testen, schalte in einer Testkopie deines Spiels den Studio-Zugriff auf API-Dienste ein, wie es der erste Abschnitt erklärt. SimulatorService lädt das Modul selbst per require, also brauchst du dafür das Skript Main aus dem Tutorial nicht.
  2. Füg in PlayerData PowerLevel = 1, und Rebirths = 0, in die Tabelle DEFAULTS ein, neben Coins = 0,.
  3. Füg im selben Modul PowerLevel: number, und Rebirths: number, zum Typ Data hinzu, damit die strikte Typprüfung die neuen Felder kennt.
  4. Ändere in SimulatorService local SAVE_PROGRESS = false zu local SAVE_PROGRESS = true.

Spieler, die gespeichert haben, bevor du die Felder hinzugefügt hast, bekommen sie automatisch: Die Funktion migrate von PlayerData füllt jedes DEFAULTS-Feld auf, das einer gespeicherten Tabelle fehlt, also starten sie mit Click Power Stufe 1 und 0 Rebirths und behalten ihre Coins. Wenn du Schritt 2 auslässt, gibt SimulatorService eine Warnung aus, welche Felder fehlen, und richtet den Spieler nicht ein.

Warum der Simulator in die Tabelle von PlayerData schreibt

Mit eingeschaltetem Speichern kopiert SimulatorService die Zahlen nirgendwohin. PlayerData.Get(player) gibt die lebende Tabelle zurück, die das Modul speichert, und der Simulator ändert Coins, PowerLevel und Rebirths genau in dieser Tabelle. Es gibt eine Kopie jeder Zahl und ein Skript, das in den Data Store schreibt. Zwei Skripte, die denselben Key speichern, überschreiben sich gegenseitig, und eines davon kann ältere Zahlen über die des anderen speichern.

Bau leaderstats nicht zusätzlich in einem Loaded-Handler, wie es das DataStore-Tutorial für andere Spiele vorschlägt: SimulatorService erstellt Coins und Rebirths schon aus der geladenen Tabelle. Wenn ein Leaderboard-Skript schon leaderstats erstellt, lösch es.

Warum nicht bei jedem Klick speichern

Roblox erlaubt jedem Server 60 + 40 × Spieler normale Data-Store-Schreibvorgänge pro Minute (die Limit-Tabelle im DataStore-Tutorial hat den Rest). Bei jedem Klick mit 15 Klicks pro Sekunde zu speichern wären 900 Schreibvorgänge pro Minute für einen Spieler, weit über den 100, die ein Server mit einem Spieler bekommt. Die ganze Tabelle alle 180 Sekunden zu speichern, wenn der Spieler geht und wenn der Server herunterfährt, kostet nur ein paar Schreibvorgänge pro Spieler, und ein Absturz verliert höchstens den Fortschritt seit dem letzten Autosave.

Wenn das Laden fehlschlägt, lässt das Modul den Spieler mit neuen Zahlen spielen, speichert sie aber nie, also kann ein fehlerhaftes Laden echten Fortschritt nicht ersetzen. Das Tutorial erklärt, wie das Modul das handhabt.

Warum der Server jede Zahl entscheidet

Exploiter kontrollieren ihr eigenes Gerät. Der Sicherheitsguide von Roblox sagt, dass sie alles in ihrer lokalen Kopie des Spiels ändern und jedes RemoteEvent und jede RemoteFunction so oft feuern oder aufrufen können, wie sie wollen, mit beliebigen Argumenten. Die Wirtschaft eines Simulators ist nur so sicher wie sein Server-Skript.

Was ein Exploiter versuchen kann, und was SimulatorService macht
Ein Exploiter versuchtWenn der Client entscheiden würdeWas SimulatorService macht
Click so schnell wie möglich in einer Schleife feuernUnbegrenzt CoinsZählt in jedem Sekundenfenster höchstens 15 Klicks und ignoriert den Rest.
Mit dem Klick eine Coin-Menge mitschickenEr wählt seine eigene BelohnungIgnoriert alle Argumente. Der Wert eines Klicks kommt aus den Zahlen des Servers.
Ein Upgrade oder einen Rebirth ohne genug Coins kaufenGratis-UpgradesPrüft den Preis gegen die Coins des Servers und antwortet "You need N more coins."
Coins in leaderstats auf dem eigenen Bildschirm bearbeitenCoins ausgeben, die er nicht hatLiest leaderstats nie. Es schreibt nur hinein, aus seiner eigenen Tabelle.
Das Attribut PowerLevel an seinem Player setzenEin größerer KlickLiest das Attribut nie, und die Änderung bleibt auf seinem Gerät.
Rebirth zweimal im selben Moment aufrufenZwei Rebirths zum Preis von einemPrüft den Preis bei jedem Aufruf neu, und zwischen Prüfung und Änderung yieldet nichts.
Die Preise in seiner Kopie von SimulatorConfig ändernBilligere UpgradesNutzt seine eigene Kopie des Moduls.

Die Regel gilt für jedes Remote in einem Simulator: Schick, was der Spieler tun will, nie, was es wert ist. Der RemoteEvents-Guide erklärt das Prüfen von Remote-Argumenten genauer.

Muster, die du in kopierten Clicker-Skripten vermeiden solltest

Häufige Muster in älteren Clicker-Tutorials, und was dieser Guide stattdessen macht
MusterDas ProblemDieser Guide
Ein LocalScript addiert Coins mit leaderstats.Coins.Value += 1Die Änderung bleibt auf diesem einen Gerät, und Exploiter kontrollieren ihr GerätDer Server addiert die Coins
clickEvent:FireServer(amount)Der Client wählt seine eigene BelohnungClick schickt keine Argumente
Kein Ratenlimit auf dem ServerDie Doku von Roblox sagt, dass man sich nie nur auf ein Limit im Client verlassen sollHöchstens 15 Klicks in jedem Sekundenfenster
SetAsync bei jedem Klick oder UpgradeVerbraucht das Schreibbudget pro ServerPlayerData speichert alle 180 Sekunden, beim Verlassen und beim Herunterfahren. Speichere sofort mit PlayerData.SaveNow nur nach etwas, das nicht verloren gehen darf, zum Beispiel einem Robux-Kauf.
Ein zweites Data-Store-Skript nur für den SimulatorZwei Skripte, die einen Key speichern, überschreiben sich gegenseitigSchreibt in die Tabelle von PlayerData
while wait(1) do-Schleifen für passives EinkommenRoblox markiert das globale wait als veraltet, ersetzt durch task.waittask.wait (siehe Erweitern)
MouseButton1Click an ButtonsFür Mausklicks dokumentiertActivated, für Maus, Touch und Controller

Schritt 5: Testen

Mach die Schritte 1 bis 8 mit SAVE_PROGRESS = false in SimulatorService, damit jeder Playtest mit neuen Zahlen beginnt. Wenn du das Speichern in Schritt 4 schon eingeschaltet hast, setz es vorerst auf false und für Schritt 9 wieder auf true.

  1. Drück auf Play. Oben auf dem Bildschirm steht 0 coins, der grüne Button zeigt Upgrade: 10 und der orange Rebirth: 1.0K.
  2. Klick zehnmal auf den lila Button Click!. Jeder Klick zeigt ein goldenes +1, und Coins in der Spielerliste steigt um 1.
  3. Drück auf Upgrade. Die Coins gehen zurück auf 0, die Statuszeile wird grün mit "Click Power is now level 2.", und der Button zeigt jetzt Upgrade: 15. Ab jetzt gibt jeder Klick 2 Coins.
  4. Drück vor dem nächsten Klick auf Rebirth. Die Statuszeile zeigt "You need 1000 more coins to rebirth.", und nichts ändert sich.
  5. Um einen Rebirth ohne 1.000 Klicks zu testen, stopp den Test, ändere Coins = 0 zu Coins = 1000 in der Zeile weit unten in SimulatorService, die neue Spieler einrichtet, und drück auf Play. Drück auf Rebirth: Die Coins gehen auf 0, Rebirths in der Spielerliste geht auf 1, die Statuszeile zeigt "Rebirth 1! Every click is now worth x2.", und der Button zeigt jetzt Rebirth: 3.0K. Jeder Klick gibt jetzt 2 Coins auf Click Power Stufe 1. Setz die Zeile danach wieder auf 0.
  6. Um das Ratenlimit zu sehen, setz MAX_CLICKS_PER_SECOND in SimulatorConfig auf 2 und klick schnell. Die "+N" erscheinen weiter, aber die Coins steigen pro Sekunde höchstens um den Wert von 2 Klicks. Setz es wieder auf 15.
  7. Wähl im Device Simulator von Studio (eine Studio-Beta; der ältere Device Emulator geht auch) ein Handy aus und drück auf Play. Prüf, dass der Click-Button weder die Coin-Anzeige noch die Buttons Upgrade und Rebirth überdeckt und dass die Statuszeile frei davon zu sehen ist, wenn du Upgrade drückst.
  8. Schließ einen Controller an oder öffne während des Playtests den Controller Emulator von Studio (Controller, im Tab Emulation), drück Select und prüf, dass du die drei Buttons erreichen und mit A drücken kannst.
  9. Mit eingeschaltetem Speichern (Schritt 4) und wieder SAVE_PROGRESS = true verdienst du ein paar Coins, drückst auf Stop und dann wieder auf Play. Deine Coins, deine Click-Power-Stufe und deine Rebirths sind wieder da.

Mach daraus einen Gewichtheber- oder Bergbau-Simulator

Viele Simulatoren ersetzen den Button durch eine Aktion in der Welt: eine Hantel heben, eine Spitzhacke schwingen, ein Schwert durch die Luft schwingen. Darunter ist es derselbe Klick. Ein Tool kann dasselbe Click-Remote feuern, also bleiben SimulatorService, seine Preise und sein Ratenlimit genau so, wie sie sind.

  1. Fahr im Explorer mit der Maus über StarterPack, füge ein Tool ein und nenn es Dumbbell. Füge darin einen Part namens Handle ein, form ihn wie eine Hantel und nimm den Haken bei Anchored raus, wie in den Tool-Schritten im Schwert-Guide.
  2. Füge ins Tool ein LocalScript namens LiftClient ein und füg den Code unten ein.
  3. Drück auf Play, rüste die Hantel aus und klick. Die Coins steigen bei jedem Heben um deine Click Power, genau wie mit dem Button.
LocalScript in dem Tool Dumbbell in StarterPack namens LiftClient
-- LocalScript im Tool Dumbbell, namens LiftClient.
-- Jedes Heben ist ein Klick: Es feuert dasselbe Click-Remote wie der Button, und der Server
-- entscheidet, was es wert ist und wie viele zählen.

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 -- Zeit zwischen zwei Hebungen auf diesem Gerät; der Server hat sein eigenes Limit
local LIFT_ANIMATION_ID = "" -- optional: "rbxassetid://" gefolgt von der ID deiner Animation

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

-- Die Hebe-Animation einmal pro Figur laden, über den Animator, den Roblox in den Humanoid legt
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() -- keine Argumente: Der Server berechnet die Belohnung
end)

Für eine Hebe-Animation erstellst du eine im Animation Editor mit der Priorität Action, veröffentlichst sie und fügst ihre ID in LIFT_ANIMATION_ID ein. Die Animationsschritte im Schwert-Guide funktionieren genauso.

  • Pass das Server-Limit an die Aktion an. LIFT_SECONDS bremst nur ehrliche Spieler: Ein Cheater kann Click aus seinem eigenen Code feuern. Wenn Heben der einzige Weg ist, etwas zu verdienen, senk MAX_CLICKS_PER_SECOND in SimulatorConfig auf das echte Tempo, zum Beispiel 2 für ein Heben alle 0,5 Sekunden, damit ein Skript nicht mehr verdienen kann als ein Spieler. Rechne dann die Tempo-Tabelle neu aus: Jede Zeit darin geht von 5 Klicks pro Sekunde aus.
  • Behalt den Button oder versteck ihn. Der Click-Button funktioniert neben dem Tool weiter. Um ihn zu verstecken, füg clickButton.Visible = false direkt nach der Zeile in SimulatorClient ein, die clickButton erstellt.
  • Nur am richtigen Ort verdienen. Damit nur in einem Gym oder einer Mine gezahlt wird, prüf auf dem Server, wo die Figur ist, bevor du den Klick zählst, zum Beispiel ihren Abstand zu einem Part in der Zone. Eine Prüfung in LiftClient würde niemanden aufhalten.

Was du als Nächstes baust: eine Bau-Reihenfolge für Simulatoren

Ein Simulator ist ein Stapel von Systemen auf dieser Schleife. Bau sie in einer Reihenfolge, in der jedes etwas zum Multiplizieren hat, und mach nach jedem einen Playtest. Das ist die Reihenfolge, die wir vorschlagen, mit dem Guide für jeden Schritt.

Eine Bau-Reihenfolge für einen Roblox-Simulator, von der Kernschleife nach außen
ReihenfolgeSystemGuideWarum an dieser Stelle
1Verdienen, Upgrade, RebirthDieser GuideAlles danach multipliziert diese Schleife, also stell ihre Zahlen zuerst mit der Tempo-Tabelle ein.
2SpeichernDataStore-Tutorial, dann Schritt 4Fortschritt, der beim erneuten Beitreten verschwindet, ist das Ende eines Simulators. Füg es hinzu, bevor Spieler etwas verlieren könnten.
3Eier und Pets als MultiplikatorenEier ausbrüten (auf Englisch) und folgende Pets (auf Englisch)Das zweite Ziel neben Coins: etwas zum Sammeln, das jeden Klick mehr wert macht.
4Zonen hinter RebirthsErweiternEin Ziel nach einem Rebirth, mit besseren Belohnungen, die auf dem Server geprüft werden.
5LeaderboardsLeaderboard-GuideEine globale Top 10 der Rebirths gibt dem langen Aufstieg einen Sinn.
6Tägliche Belohnungen und CodesTägliche Belohnungen und Codes (auf Englisch)Gründe, morgen und nach jedem Update wiederzukommen.
7Game PassesGame-Pass-Guide (auf Englisch)2x Coins, Auto-Click oder ein zusätzlicher Pet-Platz, auf dem Server geprüft. Verkauf sie, wenn die kostenlose Schleife Spaß macht.

Für die Bildschirme enthalten die kostenlosen Roblox UI Kits (auf Englisch) Bildschirme im Simulator-Stil, mit den Skripten, die sie zum Laufen bringen.

Einen Simulator erstellen, ohne die Skripte zu schreiben

Ein Simulator braucht trotzdem Skripte: Irgendetwas muss die Coins addieren, die Preise prüfen und speichern. Du musst sie aber nicht selbst schreiben:

  • Ein Simulator-Kit aus dem Creator Store. Lies seine Skripte, bevor du veröffentlichst, und prüf, dass sich Coins nur in einem Server-Script ändern, nie in einem LocalScript.
  • Ein Simulator-Generator-Plugin. Dieselbe Prüfung gilt für alles, was es erstellt.
  • Ein KI-Agent in Studio, zum Beispiel RoCode, der genau diese drei Skripte in deinem geöffneten Spiel bauen kann. Der RoCode-Abschnitt unten hat einen Prompt für diesen Guide.
  • Build, in der Roblox-App für Handys. Laut der Doku von Roblox erstellt es einfachere 2D- und 2,5D-Spiele wie Clicker aus einer Beschreibung und wird nach und nach je nach Region eingeführt.

Egal was du nutzt, mach mit dem Ergebnis die Tests in Schritt 5 und die Exploit-Prüfungen in Warum der Server jede Zahl entscheidet.

Erweitern: Pets, Zonen, Auto-Click und Leaderboards

Pets als Multiplikatoren

Ein häufiges Design macht jedes Pet zu einem Multiplikator. Speichere die Liste der IDs der Pets, die ein Spieler besitzt, in seiner gespeicherten Tabelle, und lass den Server clickValue mit dem Bonus jedes ausgerüsteten Pets multiplizieren. Brüte Eier auf dem Server aus: Der Client fragt, ob er ein Ei öffnen darf, und der Server prüft und zieht den Preis ab und wählt dann das Pet mit einem gewichteten Zufallswurf. Lass nie den Client das Ei würfeln oder sagen, welches Pet er bekommen hat. Der Inventar-Guide zeigt, wie man besessene Items hält, speichert und anzeigt, und Pets funktionieren genauso. Der Guide zum Eier-Ausbrüten (auf Englisch) baut den Wurf auf dem Server, und der Guide zu folgenden Pets (auf Englisch) lässt die Pets neben ihrem Besitzer schweben.

Zonen, die Rebirths freischalten

Eine Zone ist ein Bereich der Karte mit besseren Belohnungen hinter einer Barriere. Sperr die Belohnung, nicht nur die Tür: Alles, was in der Zone auszahlt, sollte die Rebirths des Spielers in der Tabelle des Servers prüfen, bevor es zahlt. Eine Tür, die ein LocalScript für berechtigte Spieler öffnet, ist für die Optik in Ordnung, aber Exploiter können Parts ändern und ihre Figur auf ihrem eigenen Gerät bewegen.

Auto-Click als Game Pass

Ein Autoclicker, der als Game Pass verkauft wird, sollte auf dem Server laufen. Verschieb den Inhalt des Click-Handlers in eine Funktion wie addClick(player), verbinde das Remote damit und ruf sie für Pass-Besitzer aus einer Server-Schleife mit task.wait(0.5) auf, nicht mit dem veralteten wait. Auto-Klicks zählen dann zum selben Limit pro Sekunde wie manuelle Klicks. Prüf den Besitz auf dem Server mit MarketplaceService:UserOwnsGamePassAsync, wie es der Game-Pass-Guide (auf Englisch) für seine Vorteile macht. Ein 2x-Coins-Pass funktioniert genauso: Multiplizier clickValue auf dem Server für Besitzer. Bevor du seinen Preis festlegst, zeigt der kostenlose Robux-Steuerrechner, was dir jeder Verkauf nach dem Anteil von Roblox bringt, und der DevEx-Rechner, was diese Robux in US-Dollar wert sind.

Eine globale Top 10 der Rebirths

leaderstats vergleicht nur Spieler auf demselben Server. Um die Rebirths aller Spieler zu ranken, schreib sie in einen Ordered Data Store und lies die obersten Einträge zurück, wie in Schritt 4 des Leaderboard-Guides. Ordered Data Stores erlauben weniger Schreibvorgänge als normale, 30 + 5 × Spieler pro Minute und Server, also schreib, wenn ein Spieler geht, und per Timer.

Sehr große Zahlen

Luau-Zahlen sind Doubles, die etwa 15 signifikante Stellen halten. Ein IntValue hält ganze Zahlen bis etwa 9,2 Trillionen, aber Roblox weist darauf hin, dass Werte über 2^53 (etwa 9 Billiarden) in Skripten an Genauigkeit verlieren. Mit diesen Einstellungen überschreitet der Rebirth-Preis diesen Punkt beim 29. Rebirth. Wenn dein Spiel weiter geht, stell die leaderstats-Werte auf NumberValue um (ändere IntValue in beiden Skripten), das viel größere Zahlen mit denselben etwa 15 Stellen Genauigkeit hält, und füg Suffixe zu short() hinzu.

Was ein Simulator-Spiel erfolgreich macht

Ein Simulator ist ein Zahlenspiel. Der Klick, das Upgrade und der Rebirth oben sind die ganze Schleife; ob Spieler bleiben, entscheidet, wie diese Zahlen wachsen. Alle paar Minuten sollte sich der Spieler etwas leisten können, das die nächsten Minuten schneller macht, und jede Session sollte nah an einem Ziel enden, für das er wiederkommen will.

  • Wachstum, das trägt. Upgrade-Preise wachsen schneller als das Einkommen, also dauert jede Stufe etwas länger. Ein Rebirth setzt die Coins für einen dauerhaften Multiplikator zurück, der einen alten Bereich zu einem schnellen macht und den Aufstieg wieder neu wirken lässt.
  • Dinge zum Sammeln. Bereiche zum Freischalten, Pets aus Eiern (auf Englisch), die die Einnahmen vervielfachen, und Tools zum Aufwerten geben Spielern eine Liste von Zielen über eine einzige Zahl hinaus.
  • Große Zahlen, die lesbar bleiben. Zeig 1.5M, nicht 1500000, und speichere Zahlen so, dass der Server sie auch noch vergleichen kann, wenn sie groß werden.

Monetarisierung, die zu einem Simulator passt

Typische Passes vervielfachen Coins, geben einen zusätzlichen Pet-Platz, brüten mehr Eier auf einmal aus oder klicken automatisch. Verkauf sie als Game Passes und prüf sie auf dem Server. Coin-Pakete sind Developer Products. Wenn Eier oder irgendetwas mit zufälligem Ergebnis mit Robux gekauft werden können, oder mit einer Währung, die mit Robux gekauft wurde, verlangt Roblox, dass die Chancen vor dem Kauf angezeigt werden: Lies Paid random items (auf Englisch), bevor du den Shop baust.

Was Spieler zurückbringt

Gespeicherter Fortschritt, ein neuer Bereich oder ein neues Pet-Set in Updates, tägliche Belohnungen, Codes (auf Englisch), die mit Updates angekündigt werden, und ein Leaderboard der Rebirths. Weitere Genres, jedes mit seiner Schleife, seinen Systemen und seinem Bauplan: Roblox-Spielgenres (auf Englisch).

Häufige Fehler und Lösungen

Öffne das Output-Fenster (Menü Window, dann Output), bevor du auf Play drückst. Die meisten Probleme geben dort eine Warnung oder einen Fehler aus, mit dem Namen des Skripts und der Zeile.

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

Das LocalScript wartet auf die Remotes, die SimulatorService beim Start erstellt. Prüf, dass SimulatorService ein Script ist, kein LocalScript, dass es in ServerScriptService liegt und dass Output keinen Fehler davon zeigt. Dieselbe Warnung für SimulatorConfig heißt, dass das Modul in ReplicatedStorage fehlt oder anders heißt.

Die Buttons erscheinen nie

Das LocalScript wartet auf deine leaderstats, bevor es den Bildschirm baut. Wenn Output Infinite yield possible bei leaderstats zeigt, hat SimulatorService dich noch nicht eingerichtet. Mit SAVE_PROGRESS = true wartet es auf PlayerData, also prüf, dass PlayerData in ServerScriptService liegt und ohne Fehler lädt.

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

Das Speichern ist an, aber das PlayerData-Modul hat die neuen Felder noch nicht. Füg sie wie in Schritt 4 zu DEFAULTS hinzu und drück wieder auf Play.

Die "+1" erscheinen, aber meine Coins steigen nicht

Der Server zählt die Klicks nicht. Entweder hatte SimulatorService einen Fehler (such in Output nach rotem Text davon), oder die Klicks kommen schneller an, als MAX_CLICKS_PER_SECOND erlaubt. Wenn Spieler das Limit beim normalen Spielen erreichen, erhöh es in SimulatorConfig.

Die Statuszeile zeigt "No answer from the server. Try again."

Der Aufruf von BuyUpgrade oder Rebirth ist fehlgeschlagen, statt eine Antwort zurückzugeben. Die übliche Ursache ist ein Fehler in SimulatorService, während es die Anfrage bearbeitet hat, also such in Output nach einem roten Fehler davon: Er nennt die Zeile.

Die Coin-Anzeige auf dem Bildschirm und die Spielerliste zeigen verschiedene Zahlen

Ein anderes Skript erstellt auch einen leaderstats-Ordner, also hat jeder Spieler zwei, und das LocalScript liest vielleicht den anderen. Lösch das zusätzliche Skript: SimulatorService erstellt Coins und Rebirths selbst.

Meine Coins werden jedes Mal zurückgesetzt, wenn ich neu beitrete

Das Speichern ist aus. Folge Schritt 4. Wenn es an ist und die Coins in Studio trotzdem zurückgesetzt werden, prüf, dass der Studio-Zugriff auf API-Dienste in deiner Testkopie eingeschaltet ist, wie es das DataStore-Tutorial erklärt.

Mit RoCode bauen

Wenn du das nicht von Hand einfügen willst, kann RoCode es in dem Spiel bauen, das du offen hast. RoCode ist ein unabhängiger KI-Coding-Agent und stammt nicht von Roblox: Du beschreibst das System in seinem Webchat, und sein Roblox-Studio-Plugin erstellt die Skripte in deinem Explorer, also kopierst du keinen Code aus einem Chatfenster. Prompts kannst du auf Deutsch schreiben.

Du schreibst

Bau einen Clicker-Simulator: einen großen Click-Button, der so viele Coins gibt wie meine Click-Power-Stufe mal (Rebirths + 1), einen Upgrade-Button, der 10 Coins kostet und pro Stufe um das 1,5-Fache teurer wird, und einen Rebirth-Button bei 1.000 Coins, der Coins und Upgrades zurücksetzt. Halt die Zahlen auf dem Server und begrenz Klicks auf 15 pro Sekunde. Ich habe schon ein PlayerData-Modul.

RoCode macht
  • Kann zuerst dein PlayerData-Modul und vorhandene leaderstats-Skripte mit Search Scripts und Read Script lesen, sodass es Felder zu deinen bestehenden Daten hinzufügt, statt ein zweites Speicher-Skript zu schreiben
  • Kann den Bildschirm mit dem HUD-Layout von Build UI anlegen (mit Plugin 3.9 oder neuer, im Simulator-Stil) oder die Buttons in einem LocalScript bauen, und schreibt das ModuleScript, das Server-Script und das LocalScript mit Create Script
  • Ist angewiesen, jedes Skript, das es schreibt, mit Check Script auf Kompilierfehler zu prüfen, das es in Studio kompiliert, ohne es auszuführen
  • Setzt vor und nach jeder Änderungsrunde einen Undo-Punkt, sodass Strg+Z jeweils eine Runde zurückgeht

RoCode kann keine Game Passes oder Developer Products erstellen und keine Pet-Meshes und Icons hochladen: Das machst du im Creator Hub und in Studio. Mit Plugin 3.9.11 oder neuer kann RoCode dein Spiel in Studio playtesten und eine Testfigur steuern, um zu prüfen, ob es funktioniert, und mit Plugin 3.9.15 oder neuer kann die Testfigur Buttons auf dem Bildschirm anklicken, zum Beispiel Click drücken und prüfen, ob die Coins gestiegen sind. Es entscheidet selbst, wann es einen Playtest macht, bis zu 2 pro Build plus 1, um seinen eigenen Fix zu prüfen, und prüft nur, was es zum Testen ausgewählt hat, also teste die Schleife auch selbst. Ein ganzer Simulator sind mehrere Prompts, ein System nach dem anderen: wie das Bauen mit einem System pro Prompt mit RoCode funktioniert. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Wie erstelle ich ein Simulator-Spiel in Roblox ohne Scripting?

Ein funktionierender Simulator braucht Skripte: Irgendetwas muss Coins addieren, Preise prüfen und den Fortschritt speichern. Du kannst die drei Skripte aus diesem Guide so einfügen, wie sie sind, und nur die Zahlen in SimulatorConfig ändern, oder ein Creator-Store-Kit, ein Plugin oder einen KI-Agenten sie erstellen lassen und prüfen, dass der Server über die Coins entscheidet. Die Möglichkeiten.

Wie funktioniert ein Rebirth-System?

Ein Rebirth tauscht deine Coins und Upgrades gegen einen dauerhaften Bonus. In diesem Guide kostet der erste Rebirth 1.000 Coins; er setzt Coins auf 0 und Click Power auf Stufe 1, addiert 1 zu Rebirths, und jeder Klick wird dann mit Rebirths + 1 multipliziert. Jeder Rebirth kostet dreimal so viel wie der vorherige.

Wie mache ich einen Stärke- oder Gewichtheber-Simulator?

Gib den Spielern ein Tool, zum Beispiel eine Hantel, dessen LocalScript bei Tool.Activated dasselbe Click-Remote feuert. Der Server berechnet die Belohnung genau wie bei einem Button-Klick. Senk das Klick-Limit des Servers auf das Hebe-Tempo, damit ein Skript nicht mehr verdienen kann als ein Spieler. Die Version zum Gewichtheben hat das Skript.

Welche Systeme braucht ein Simulator-Spiel?

Zuerst die Schleife aus Verdienen, Upgrade und Rebirth, dann Speichern, dann Pets oder eine andere Sammlung, die die Einnahmen vervielfacht, Zonen, die Rebirths freischalten, Leaderboards, tägliche Belohnungen und Codes, und zuletzt die Game Passes. Die Bau-Reihenfolge verlinkt für jedes einen Guide.

Wie lange sollte ein Rebirth dauern?

Lang genug, dass Spieler vorher mehrere Upgrades kaufen, kurz genug, dass die erste Session einen erreicht. Mit den Zahlen aus diesem Guide kommt der erste Rebirth nach etwa 1,2 Minuten bei 5 Klicks pro Sekunde; mit REBIRTH_BASE_COST auf 10.000 sind es etwa 8 Minuten. Die Tempo-Tabelle zeigt mehr Einstellungen.

Wie stoppe ich Autoclicker?

Der Server zählt pro Spieler in jedem Sekundenfenster höchstens 15 Klicks und ignoriert den Rest. Unter diesem Limit sieht ein Skript genauso aus wie ein schneller Spieler, also schützt das Limit deine Wirtschaft. Du kannst Auto-Click auch als Game Pass verkaufen, der auf dem Server läuft.

Warum werden meine Coins zurückgesetzt, wenn ich neu beitrete?

Noch speichert sie nichts. Füg das PlayerData-Modul aus dem DataStore-Tutorial hinzu, trag PowerLevel und Rebirths in seine DEFAULTS ein und setz SAVE_PROGRESS = true in SimulatorService, wie in Schritt 4.

Wie füge ich Pets zu meinem Simulator hinzu?

Mach jedes Pet zu einem Multiplikator, den der Server auf Klicks anwendet. Brüte Eier auf dem Server mit einer gewichteten Zufallsauswahl aus, speichere die IDs der Pets mit den übrigen Daten des Spielers und zeig sie mit einer Inventar-GUI wie der im Inventar-Guide.

Sollen Spieler auf einen Part oder einen Button klicken?

Beides geht. Ein Button auf dem Bildschirm passt zu Handys, und ein Part mit einem ClickDetector passt zu einem Spiel, das in der Welt spielt. Laut der Doku von Roblox prüft der Server ClickDetector-Events überhaupt nicht, also begrenz diese Klicks genauso auf dem Server.

Quellen und weiterführende Links

So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 14. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.

Probier RoCode in deinem eigenen Spiel aus.

Jeden Tag kostenlose Credits, ohne Karte. Installiere das Plugin, beschreibe das Feature und prüfe, was in Studio ankommt.