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
So funktioniert die Kernschleife eines Simulators
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.
| Aktion | Was sie kostet | Was sie bringt | Wer entscheidet |
|---|---|---|---|
| Click | Nichts | Coins in Höhe von Click Power × (Rebirths + 1) | Der Server, der in jedem Sekundenfenster höchstens 15 Klicks zählt |
| Upgrade | 10 Coins, dann für jede Stufe das 1,5-Fache des letzten Preises | Eine Click-Power-Stufe mehr, bis Stufe 50 | Der Server, mit seiner eigenen Kopie der Preise |
| Rebirth | 1.000 Coins, dann für jeden Rebirth das 3-Fache des letzten Preises | Coins zurück auf 0 und Click Power zurück auf Stufe 1, dazu dauerhaft +1 auf den Multiplikator | Der 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.
| Teil | Wo es liegt | Was es macht |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Preise, Limits und die Formeln für den Wert eines Klicks, den Upgrade-Preis und den Rebirth-Preis. Beide Seiten lesen es. |
Script SimulatorService | ServerScriptService | Hält die Zahlen jedes Spielers, verarbeitet Klicks, Upgrades und Rebirths und füllt leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (SimulatorService erstellt ihn) | Das RemoteEvent Click und die RemoteFunctions BuyUpgrade und Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | Baut die Buttons, schickt Klicks und Anfragen und zeigt die Zahlen des Servers. |
ModuleScript PlayerData (optional) | ServerScriptService | Speichert den Fortschritt zwischen Besuchen. Es kommt aus dem DataStore-Tutorial und wird nur für Schritt 4 gebraucht. |
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.
- Fahr im Explorer mit der Maus über ReplicatedStorage, klick auf den Button + und füge ein ModuleScript ein.
- Benenn es in
SimulatorConfigum (Groß- und Kleinschreibung zählt) und ersetz seinen Inhalt durch den Code unten.
-- 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.
| Click-Power-Stufe | Preis der nächsten Stufe | Coins pro Klick, ohne Rebirth | Coins pro Klick, 1 Rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
Rebirths kosten 1.000 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.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1.000 (dieser Guide) | 1,2 | 2,7 | 4,8 |
| 5.000 | 4,3 | 10,1 | 18,3 |
| 10.000 | 8,2 | 16,9 | 33,2 |
| 25.000 | 16,7 | 40,1 | 74,5 |
| 50.000 | 32,8 | 68,8 | 137,8 |
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:
-- 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.
- Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts und füge ein LocalScript namens
SimulatorClientein. - Ersetz seinen Inhalt durch den Code unten und drück auf Play.
-- 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
UIAspectRatioConstrainthält ihn quadratisch, und einUISizeConstraintbegrenzt 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 zuUNITShinzu 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.
- Folge Schritt 1 des DataStore-Tutorials, um das ModuleScript
PlayerDatazu 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 SkriptMainaus dem Tutorial nicht. - Füg in PlayerData
PowerLevel = 1,undRebirths = 0,in die TabelleDEFAULTSein, nebenCoins = 0,. - Füg im selben Modul
PowerLevel: number,undRebirths: number,zum TypDatahinzu, damit die strikte Typprüfung die neuen Felder kennt. - Ändere in SimulatorService
local SAVE_PROGRESS = falsezulocal 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.
| Ein Exploiter versucht | Wenn der Client entscheiden würde | Was SimulatorService macht |
|---|---|---|
| Click so schnell wie möglich in einer Schleife feuern | Unbegrenzt Coins | Zählt in jedem Sekundenfenster höchstens 15 Klicks und ignoriert den Rest. |
| Mit dem Klick eine Coin-Menge mitschicken | Er wählt seine eigene Belohnung | Ignoriert alle Argumente. Der Wert eines Klicks kommt aus den Zahlen des Servers. |
| Ein Upgrade oder einen Rebirth ohne genug Coins kaufen | Gratis-Upgrades | Prüft den Preis gegen die Coins des Servers und antwortet "You need N more coins." |
| Coins in leaderstats auf dem eigenen Bildschirm bearbeiten | Coins ausgeben, die er nicht hat | Liest leaderstats nie. Es schreibt nur hinein, aus seiner eigenen Tabelle. |
| Das Attribut PowerLevel an seinem Player setzen | Ein größerer Klick | Liest das Attribut nie, und die Änderung bleibt auf seinem Gerät. |
| Rebirth zweimal im selben Moment aufrufen | Zwei Rebirths zum Preis von einem | Prüft den Preis bei jedem Aufruf neu, und zwischen Prüfung und Änderung yieldet nichts. |
| Die Preise in seiner Kopie von SimulatorConfig ändern | Billigere Upgrades | Nutzt 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
| Muster | Das Problem | Dieser Guide |
|---|---|---|
Ein LocalScript addiert Coins mit leaderstats.Coins.Value += 1 | Die Änderung bleibt auf diesem einen Gerät, und Exploiter kontrollieren ihr Gerät | Der Server addiert die Coins |
clickEvent:FireServer(amount) | Der Client wählt seine eigene Belohnung | Click schickt keine Argumente |
| Kein Ratenlimit auf dem Server | Die Doku von Roblox sagt, dass man sich nie nur auf ein Limit im Client verlassen soll | Höchstens 15 Klicks in jedem Sekundenfenster |
SetAsync bei jedem Klick oder Upgrade | Verbraucht das Schreibbudget pro Server | PlayerData 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 Simulator | Zwei Skripte, die einen Key speichern, überschreiben sich gegenseitig | Schreibt in die Tabelle von PlayerData |
while wait(1) do-Schleifen für passives Einkommen | Roblox markiert das globale wait als veraltet, ersetzt durch task.wait | task.wait (siehe Erweitern) |
MouseButton1Click an Buttons | Für Mausklicks dokumentiert | Activated, 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.
- Drück auf Play. Oben auf dem Bildschirm steht 0 coins, der grüne Button zeigt Upgrade: 10 und der orange Rebirth: 1.0K.
- Klick zehnmal auf den lila Button Click!. Jeder Klick zeigt ein goldenes +1, und Coins in der Spielerliste steigt um 1.
- 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.
- Drück vor dem nächsten Klick auf Rebirth. Die Statuszeile zeigt "You need 1000 more coins to rebirth.", und nichts ändert sich.
- Um einen Rebirth ohne 1.000 Klicks zu testen, stopp den Test, ändere
Coins = 0zuCoins = 1000in 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. - Um das Ratenlimit zu sehen, setz
MAX_CLICKS_PER_SECONDin 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. - 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.
- 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.
- Mit eingeschaltetem Speichern (Schritt 4) und wieder
SAVE_PROGRESS = trueverdienst 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.
- Fahr im Explorer mit der Maus über StarterPack, füge ein Tool ein und nenn es
Dumbbell. Füge darin einen Part namensHandleein, form ihn wie eine Hantel und nimm den Haken bei Anchored raus, wie in den Tool-Schritten im Schwert-Guide. - Füge ins Tool ein LocalScript namens
LiftClientein und füg den Code unten ein. - 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 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_SECONDSbremst nur ehrliche Spieler: Ein Cheater kann Click aus seinem eigenen Code feuern. Wenn Heben der einzige Weg ist, etwas zu verdienen, senkMAX_CLICKS_PER_SECONDin 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 = falsedirekt nach der Zeile in SimulatorClient ein, dieclickButtonerstellt. - 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.
| Reihenfolge | System | Guide | Warum an dieser Stelle |
|---|---|---|---|
| 1 | Verdienen, Upgrade, Rebirth | Dieser Guide | Alles danach multipliziert diese Schleife, also stell ihre Zahlen zuerst mit der Tempo-Tabelle ein. |
| 2 | Speichern | DataStore-Tutorial, dann Schritt 4 | Fortschritt, der beim erneuten Beitreten verschwindet, ist das Ende eines Simulators. Füg es hinzu, bevor Spieler etwas verlieren könnten. |
| 3 | Eier und Pets als Multiplikatoren | Eier ausbrüten (auf Englisch) und folgende Pets (auf Englisch) | Das zweite Ziel neben Coins: etwas zum Sammeln, das jeden Klick mehr wert macht. |
| 4 | Zonen hinter Rebirths | Erweitern | Ein Ziel nach einem Rebirth, mit besseren Belohnungen, die auf dem Server geprüft werden. |
| 5 | Leaderboards | Leaderboard-Guide | Eine globale Top 10 der Rebirths gibt dem langen Aufstieg einen Sinn. |
| 6 | Tägliche Belohnungen und Codes | Tägliche Belohnungen und Codes (auf Englisch) | Gründe, morgen und nach jedem Update wiederzukommen. |
| 7 | Game Passes | Game-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.
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.
- 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
- Roblox Creator Docs: Securing the client-server boundary (auf Englisch). Ratenlimits, das Beispiel mit dem In-Game-Shop und ClickDetector-Events
- Roblox Creator Docs: Security and cheat mitigation tactics (auf Englisch). was ein Exploiter auf seinem eigenen Gerät kontrolliert
- Roblox Creator Docs: Remote events and callbacks (auf Englisch). FireServer, der Player-Parameter, InvokeServer und OnServerInvoke
- Roblox Creator Docs: Leaderboards (auf Englisch). leaderstats und Ordered Data Stores
- Roblox Creator Docs: Data store error codes and limits (auf Englisch). Schreiblimits pro Server für normale und Ordered Data Stores
- Roblox Engine API: GuiButton (auf Englisch). Activated auf Desktop, Handy und Konsole
- Roblox Engine API: GuiService (auf Englisch). AutoSelectGuiEnabled und das Auswählen von GUI-Objekten mit einem Gamepad
- Roblox Engine API: IntValue (auf Englisch). der 64-Bit-Bereich und der Genauigkeitsverlust über 2^53
- Roblox Creator Docs: Size modifiers and constraints (auf Englisch). UIAspectRatioConstraint und UISizeConstraint
- Roblox Creator Docs: Studio testing modes (auf Englisch). Device Simulator und Controller Emulator
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.