Poradnik · Systemy gry

Jak zrobić symulator w Roblox

Prawie wszystkie symulatory kręcą się na jednej pętli: robisz coś prostego i dostajesz walutę, wydajesz ją na ulepszenia, które dają ją szybciej, a potem robisz rebirth, żeby zacząć od nowa ze stałym mnożnikiem. W tym poradniku budujemy tę pętlę jako clicker z trzech skryptów, gdzie każdą liczbę decyduje serwer, i zapisujemy postęp modułem PlayerData z poradnika o DataStore. Jeśli jeszcze nigdy nie robiłeś gry w Studio, najpierw zrób krótki tor z monetami.

Zaktualizowano 20 listopada 202623 min czytaniaAutor:

W skrócie

Symulator w Roblox to jedna pętla: klikaj, żeby dostawać monety, wydawaj je na ulepszenia, które dają więcej, a potem rób rebirth dla stałego mnożnika. Ceny trzymaj w ModuleScript w ReplicatedStorage. Jeden Script w ServerScriptService przechowuje każdemu graczowi Coins, Click Power i Rebirths, zalicza nie więcej niż 15 kliknięć na sekundę z RemoteEvent Click i sprzedaje ulepszenia i rebirthy przez RemoteFunction po sprawdzeniu ceny. LocalScript pokazuje przyciski Click, Upgrade i Rebirth. Z liczbami z tego poradnika gracz, który klika 5 razy na sekundę, dochodzi do pierwszego rebirtha po około 1.2 minuty, a tabela tempa pokazuje, co zmienić, żeby wspinaczka trwała dłużej.

  • Kliknięcie nie przekazuje niczego poza samym kliknięciem. Ile jest warte, liczy serwer, więc zmodyfikowany klient nie może sobie dopisać monet.
  • Zapisuj całą tabelę według timera i przy wyjściu gracza, a nie przy każdym kliknięciu. Roblox pozwala każdemu serwerowi na 60 + 40 × gracze zapisów do magazynu danych na minutę.
  • Nie umiesz skryptować? Tę samą pętlę może zbudować zestaw z Creator Store, plugin albo agent AI. Sprawdź, czy o monetach decyduje serwer: opcje.
  • Potrzebujesz siłowni albo kopalni zamiast przycisku? Tool może wywoływać ten sam remote Click: wersja z hantlem. Potem dodawaj systemy według kolejności budowy niżej.
Na tej stronie
  1. Jak to działa
  2. 1. Moduł ustawień
  3. 2. Skrypt serwerowy
  4. 3. Przyciski
  5. 4. Zapis
  6. Dlaczego decyduje serwer
  7. 5. Sprawdzenie
  8. Wersja z hantlem
  9. Kolejność budowy
  10. Bez skryptowania
  11. Jak rozbudować
  12. Gatunek
  13. Common errors
  14. Z RoCode
  15. Najczęstsze pytania
  16. Źródła i dalsza lektura

Jak zbudowana jest główna pętla symulatora

IlustracjaGracz kupuje Click Power poziomu 2 za 10 monet, potem (przyspieszone) zbiera 1 000 monet i robi rebirth: monety i ulepszenia się resetują, a każde kliknięcie jest warte x2.

Symulator to pętla trzech akcji. Gracz raz za razem robi coś prostego, żeby zarobić walutę, wydaje ją na ulepszenia, które dają ją szybciej, a gdy ulepszenia robią się drogie, robi rebirth: oddaje monety i ulepszenia za bonus, który zostaje na zawsze, i znowu się wspina, już szybciej. W innych symulatorach zamiast klikać podnosi się hantle, kopie albo zbiera przedmioty, ale pętla pod spodem jest ta sama.

Trzy akcje w pętli tego poradnika
AkcjaIle kosztujeCo dajeKto decyduje
KliknięcieNicMonety równe Click Power × (Rebirths + 1)Serwer, który zalicza nie więcej niż 15 kliknięć w każdym oknie trwającym sekundę
Ulepszenie10 monet, dalej 1.5 raza więcej niż poprzednia cena za każdy poziomKolejny poziom Click Power, do 50.Serwer, według swojej kopii cen
Rebirth1 000 monet, dalej 3 razy więcej niż poprzednia cena za każdy rebirthMonety z powrotem na 0 i Click Power z powrotem na poziom 1, plus stałe +1 do mnożnikaSerwer

Każda liczba żyje na serwerze. Urządzenie gracza rysuje przyciski i prosi ("kliknąłem", "chcę ulepszenie"), a serwer decyduje, ile to kosztuje i czy można to zrobić. Skrypty clickerów, które się psuje, często dodają monety w LocalScript albo pozwalają klientowi przysłać, ile monet dodać.

Z czego składa się symulator
ElementGdzie jestCo robi
ModuleScript SimulatorConfigReplicatedStorageCeny, limity i wzory na wartość kliknięcia, cenę ulepszenia i cenę rebirtha. Czytają go obie strony.
Script SimulatorServiceServerScriptServicePrzechowuje liczby każdego gracza, obsługuje kliknięcia, ulepszenia i rebirthy i wypełnia leaderstats.
Folder SimulatorRemotesReplicatedStorage (tworzy go SimulatorService)RemoteEvent Click i RemoteFunction BuyUpgrade i Rebirth.
LocalScript SimulatorClientStarterPlayerScriptsBuduje przyciski, wysyła kliknięcia i żądania i pokazuje liczby serwera.
ModuleScript PlayerData (opcjonalnie)ServerScriptServiceZapisuje postęp między wejściami. Pochodzi z poradnika o DataStore i jest potrzebny tylko w kroku 4.
Explorer w trakcie gry. SimulatorService tworzy SimulatorRemotes i trzy remote’y przy starcie gry, a PlayerData pojawia się dopiero po tym, jak dodasz zapis w kroku 4.
ReplicatedStorage
  SimulatorConfig ModuleScript new
  SimulatorRemotes Folder new
    Click RemoteEvent new
    BuyUpgrade RemoteFunction new
    Rebirth RemoteFunction new
ServerScriptService
  SimulatorService Script new
  PlayerData ModuleScript
StarterPlayer
  StarterPlayerScripts
    SimulatorClient LocalScript new

Krok 1: przenieś ceny i wzory do modułu

Każda liczba, którą możesz chcieć podkręcić, idzie do jednego ModuleScript: ile warte jest kliknięcie, ile kosztuje każde ulepszenie i rebirth i limit kliknięć. Serwer decyduje według niego, a LocalScript bierze z niego ceny do przycisków, więc każda zmiana to jedna poprawka w jednym miejscu.

  1. W Explorerze najedź kursorem na ReplicatedStorage, kliknij przycisk + i wstaw ModuleScript.
  2. Zmień jego nazwę na SimulatorConfig (nazwy rozróżniają wielkość liter) i zastąp jego zawartość kodem poniżej.
ModuleScript w ReplicatedStorage o nazwie SimulatorConfig
-- Wszystkie liczby głównej pętli i wzory, których używają obie strony. Klient tylko
-- pokazuje według nich ceny; serwer decyduje według własnej kopii.

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- cena Click Power poziomu 2
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- każdy poziom kosztuje 1.5 raza więcej niż poprzedni
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- monety na pierwszy rebirth
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- każdy rebirth kosztuje 3 razy więcej niż poprzedni
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- kliknięcia ponad to w jednej sekundzie są ignorowane

-- Monety za jedno kliknięcie: poziom Click Power razy 1 + liczba rebirthów
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- Cena następnego poziomu Click Power
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- Monety potrzebne na następny rebirth
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

Gracze mogą przeczytać ModuleScript w ReplicatedStorage, więc te ceny są publiczne. To w porządku: i tak są napisane na przyciskach. Klient i serwer uruchamiają każdy swoją kopię modułu, więc gracz, który zmieni liczby na swoim urządzeniu, niczego nie zmieni na serwerze.

Co dają wzory z tymi ustawieniami
Poziom Click PowerCena następnego poziomuMonet za kliknięcie, bez rebirthówMonet za kliknięcie, 1 rebirth
11012
21524
32236
43348
550510

Rebirthy kosztują 1 000 monet, potem 3 000, potem 9 000, bo rebirthCost za każdym razem mnoży cenę przez 3. Po jednym rebirthcie każde kliknięcie jest warte dwa razy więcej, po dwóch trzy razy więcej i tak dalej.

Ile trwa rebirth z tymi liczbami

Wzory decydują, ile trwa pętla, więc warto policzyć liczby, zanim zrobią to gracze. Tabela zakłada, że gracz robi rebirth, gdy tylko może go opłacić, a w pozostałym czasie kupuje następny poziom Click Power, gdy może go opłacić i kosztuje on mniej niż rebirth. Czas liczony jest od nowego startu, więc ostatnia kolumna to łączny czas do 3 rebirthów.

Minuty od nowego startu do każdego rebirtha przy 5 kliknięciach na sekundę, według REBIRTH_BASE_COST. Policzone ze wzorów SimulatorConfig, a nie zmierzone na graczach
REBIRTH_BASE_COSTRebirth 1Rebirth 2Rebirth 3
1 000 (ten poradnik)1.22.74.8
5 0004.310.118.3
10 0008.216.933.2
25 00016.740.174.5
50 00032.868.8137.8

Bez rebirthów poziom Click Power 5 przychodzi po 34 kliknięciach, poziom 10 po 122, a poziom 13 po 285. Z domyślnymi liczbami gracz potem przestaje ulepszać, bo poziom 14 kosztuje 1 297 monet, więcej niż rebirth za 1 000 monet, a pierwszy rebirth przychodzi po łącznie 362 kliknięciach. Przy serwerowym limicie 15 kliknięć na sekundę podziel każdy czas przez 3. Zmienisz dowolną liczbę w SimulatorConfig, a te czasy zmienią się razem z nią, więc policz je od nowa.

Ustawianie wzrostu

Dwie liczby _GROWTH ustalają, jak szybko rosną ceny. Przy 1.5 każde ulepszenie kosztuje półtora raza więcej niż poprzednie, a każdy poziom dodaje tylko jedną monetę za kliknięcie (przed mnożnikiem rebirthów), więc każdy nowy poziom zwraca się coraz dłużej. To właśnie to spowolnienie sprawia, że rebirth się opłaca. Podnieś wzrost dla dłuższej wspinaczki, obniż dla szybszej i trzymaj REBIRTH_BASE_COST na tyle wysoko, żeby gracze kupili kilka ulepszeń przed pierwszym rebirthem.

Żeby pierwszy rebirth był po kilku minutach, a nie po około jednej, podnieś REBIRTH_BASE_COST do 5 000 albo 10 000.

Krok 2: dodaj skrypt serwerowy

Ten Script zarządza każdą liczbą. Tworzy remote’y, daje każdemu graczowi folder leaderstats z Coins i Rebirths i odpowiada na trzy żądania. Najedź kursorem na ServerScriptService, wstaw Script, zmień jego nazwę na SimulatorService i zastąp zawartość tym kodem:

Script w ServerScriptService o nazwie SimulatorService
-- Zarządza każdą liczbą: kliknięcia dają monety tutaj, ulepszenia i rebirthy kupuje się tutaj,
-- a leaderstats tylko pokazują wynik.

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

-- false: przy każdym wejściu wszyscy zaczynają od zera. true: wczytywanie i zapis przez moduł PlayerData
-- z poradnika o DataStore (najpierw dodaj PowerLevel = 1 i Rebirths = 0 do jego DEFAULTS).
local SAVE_PROGRESS = false

type Config = {
	MAX_POWER_LEVEL: number,
	MAX_CLICKS_PER_SECOND: number,
	clickValue: (powerLevel: number, rebirths: number) -> number,
	upgradeCost: (powerLevel: number) -> number,
	rebirthCost: (rebirths: number) -> number,
}
local Config = require(ReplicatedStorage:WaitForChild("SimulatorConfig")) :: Config

type Stats = { Coins: number, PowerLevel: number, Rebirths: number }

local remotes = Instance.new("Folder")
remotes.Name = "SimulatorRemotes"
local clickEvent = Instance.new("RemoteEvent")
clickEvent.Name = "Click"
clickEvent.Parent = remotes
local buyUpgrade = Instance.new("RemoteFunction")
buyUpgrade.Name = "BuyUpgrade"
buyUpgrade.Parent = remotes
local rebirthRemote = Instance.new("RemoteFunction")
rebirthRemote.Name = "Rebirth"
rebirthRemote.Parent = remotes
remotes.Parent = ReplicatedStorage

local playerStats: { [Player]: Stats } = {}
local windowStart: { [Player]: number } = {} -- kiedy zaczęło się bieżące okno sekundowe tego gracza
local clickCount: { [Player]: number } = {} -- kliknięcia zaliczone w tym oknie

-- Kopiuje liczby serwera tam, gdzie widzą je gracze: do leaderstats i jednego atrybutu
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

-- Uruchamia gracza z przekazanymi danymi (nowe liczby albo zapisana tabela)
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

-- Kliknięcie nie niesie liczb: ile jest warte, liczy serwer
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 -- autoclicker albo skrypt, który wywołuje remote w pętli
	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
	-- Rebirth wymienia monety i ulepszenia na stały mnożnik
	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

-- Startowe liczby: nowe albo tabela, którą wczytuje i zapisuje moduł PlayerData
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) -- ta sama tabela, którą zapisuje PlayerData, więc zapisuje się każda zmiana
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- wszyscy, których dane wczytały się przed uruchomieniem tego skryptu
	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 dociera do gracza jako atrybut PowerLevel na jego obiekcie Player, a nie jako trzecia wartość w leaderstats, więc lista graczy pokazuje tylko Coins i Rebirths. Atrybuty, które ustawia serwer, replikują się na urządzenie gracza; zmiana, którą gracz zrobi na swoim urządzeniu, tam zostaje.

Kliknięcia i limit częstotliwości

Remote Click nie przekazuje argumentów. Na serwerze pierwszym parametrem handlera OnServerEvent jest zawsze gracz, który go wywołał, więc serwer wie, kto kliknął, bierze jego poziom Click Power i Rebirths i dodaje clickValue do jego Coins. W żądaniu nie ma nic, co oszust mógłby zmienić.

W poradniku Roblox o bezpieczeństwie napisano, żeby nigdy nie polegać tylko na limicie częstotliwości na kliencie, a dawanie waluty jest tam wśród akcji, które trzeba ograniczać. Serwer liczy kliknięcia każdego gracza w oknach po jednej sekundzie: pierwsze kliknięcie otwiera okno, a gdy zaliczono 15 kliknięć, resztę ignoruje, dopóki od początku okna nie minie sekunda. Skrypt, który wywołuje remote w pętli, dostaje nie więcej niż 15 zaliczonych kliknięć w każdym oknie. Żeby pozwolić klikać szybciej albo wolniej, zmień MAX_CLICKS_PER_SECOND w SimulatorConfig.

Ulepszenia i rebirthy

BuyUpgrade i Rebirth to RemoteFunction, więc przycisk może poczekać na odpowiedź i ją pokazać. Każdy handler bierze cenę z serwerowej kopii SimulatorConfig, sprawdza Coins gracza i dopiero potem coś zmienia. Zwraca true albo false i wiadomość, na przykład "You need 5 more coins.", którą LocalScript pokazuje w linii statusu.

Między sprawdzeniem ceny a zmianą nic nie czeka i nie oddaje wykonania (yield), więc dwa żądania od jednego gracza nie mogą oba przejść sprawdzenia, zanim pierwsze zabierze monety. Rebirth ustawia Coins na 0, Click Power na poziom 1 i dodaje 1 do Rebirths, a wzór kliknięcia zamienia to w mnożnik Rebirths + 1.

Przełącznik SAVE_PROGRESS

Z SAVE_PROGRESS = false każdy gracz przy każdym wejściu zaczyna od 0 monet i tego właśnie potrzebujesz, gdy budujesz grę. Krok 4 go włącza. Wtedy skrypt czeka, aż moduł PlayerData wczyta każdego gracza, i pracuje prosto na tej tabeli, którą zapisuje ten moduł, więc każda moneta i każdy rebirth zapisują się bez dodatkowego kodu.

Krok 3: zbuduj przyciski

Ten LocalScript buduje cały ekran w kodzie: licznik monet na górze, duży przycisk Click na środku, przyciski Upgrade i Rebirth na dole i linię statusu na odpowiedzi serwera. Sam nigdy nie zmienia żadnej liczby.

  1. W Explorerze rozwiń StarterPlayer, najedź kursorem na StarterPlayerScripts i wstaw LocalScript o nazwie SimulatorClient.
  2. Zastąp jego zawartość kodem poniżej i kliknij Play.
LocalScript w StarterPlayerScripts o nazwie SimulatorClient
-- Buduje przyciski symulatora i pokazuje liczby serwera. Sam nigdy ich nie zmienia.

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))
-- Przycisk Click zostaje kwadratowy, pod rozmiar ekranu i nie większy niż 200 na 200,
-- żeby na telefonie mieścił się między licznikiem monet a przyciskami na dole
local square = Instance.new("UIAspectRatioConstraint")
square.Parent = clickButton
local maxSize = Instance.new("UISizeConstraint")
maxSize.MaxSize = Vector2.new(200, 200)
maxSize.Parent = clickButton

local upgradeButton = newButton(gui, "", UDim2.new(0.5, -110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(40, 150, 90))
local rebirthButton = newButton(gui, "", UDim2.new(0.5, 110, 1, -60), UDim2.fromOffset(200, 56), Color3.fromRGB(200, 90, 40))

local status = Instance.new("TextLabel")
status.AnchorPoint = Vector2.new(0.5, 1)
status.Position = UDim2.new(0.5, 0, 1, -96)
status.Size = UDim2.fromOffset(480, 28)
status.BackgroundTransparency = 1
status.TextColor3 = Color3.new(1, 1, 1)
status.FontFace = BOLD
status.TextSize = 20
status.Text = ""
status.Parent = gui

gui.Parent = player:WaitForChild("PlayerGui")

local function powerLevel(): number
	local level = player:GetAttribute("PowerLevel")
	return if type(level) == "number" then level else 1
end

local function update()
	coinsLabel.Text = `{short(coins.Value)} coins`
	local level = powerLevel()
	upgradeButton.Text = if level >= Config.MAX_POWER_LEVEL
		then "Click Power maxed"
		else `Upgrade: {short(Config.upgradeCost(level))}`
	rebirthButton.Text = `Rebirth: {short(Config.rebirthCost(rebirths.Value))}`
end
coins.Changed:Connect(update)
rebirths.Changed:Connect(update)
player:GetAttributeChangedSignal("PowerLevel"):Connect(update)
update()

-- "+N", który wyskakuje nad przyciskiem. Liczba to tylko zgadywanie dla wyglądu;
-- ile kliknięcie jest naprawdę warte, decyduje serwer.
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)

Przyciski używają Activated, które Roblox wywołuje przy kliknięciu lewym przyciskiem myszy na komputerze, przy dotknięciu na telefonie i przy naciśnięciu A (albo krzyżyka) na padzie w trybie nawigacji po UI.

Na padzie A naciska tylko zaznaczony przycisk. Gdy włączone jest GuiService.AutoSelectGuiEnabled, przycisk Select na padzie zaznacza twoje przyciski na ekranie; dalej gracze mogą przechodzić między nimi i naciskać A. Jeśli chcesz, żeby przycisk pada klikał od razu, podepnij go przez ContextActionService i wywołuj z niego ten sam remote Click.

Cztery szczegóły w skrypcie:

  • Przycisk Click skaluje się pod ekran. Jego rozmiar to część ekranu, UIAspectRatioConstraint trzyma go kwadratowym, a UISizeConstraint ogranicza do 200 na 200 pikseli. Na monitorze ma 200 pikseli szerokości; na telefonie się zmniejsza i mieści się między licznikiem monet a przyciskami na dole. Jeśli przesuwasz elementy, trzymaj go z dala od nich: Rebirth nie ma potwierdzenia, więc przypadkowe dotknięcie może zresetować monety i ulepszenia gracza.
  • Wyskakujące "+N" jest tylko dla wyglądu. Bierze kliencką kopię wzoru. Jeśli serwer zignoruje kliknięcie przez limit częstotliwości, "+N" i tak się pojawi, ale monety się nie zmienią.
  • short() robi duże liczby czytelnymi. 1 234 pokazuje się jako 1.2K, a 5 600 000 jako 5.6M. Funkcja zaokrągla w dół, więc licznik nigdy nie pokazuje więcej, niż masz. Dla liczb większych niż T (biliony) dodaj wpisy do UNITS.
  • Ekran aktualizuje się według eventów. Nasłuchuje wartości Coins i Rebirths i atrybutu PowerLevel, więc ceny na przyciskach są poprawne, niezależnie od tego, jak zmieniają się liczby.

ScreenGui ma ResetOnSpawn ustawione na false, więc zostaje, gdy postać się odradza. Tu to ważne: LocalScript w StarterPlayerScripts kopiuje się do gracza raz, przy wejściu, więc nie zbudowałby ekranu od nowa.

Krok 4: zapisuj postęp przez PlayerData

Na razie wszystko się resetuje, gdy gracz wychodzi. Zamiast drugiego skryptu zapisu symulator podłącza się do modułu PlayerData z poradnika o DataStore. Ten moduł już ponawia nieudane zapytania, robi autozapis co 180 sekund, zapisuje przy wyjściu gracza i przy wyłączaniu serwera i nigdy nie zapisuje gracza, którego dane się nie wczytały.

  1. Przejdź krok 1 poradnika o DataStore, żeby dodać ModuleScript PlayerData do ServerScriptService. Żeby sprawdzić zapis w Studio, włącz dostęp Studio do API services w kopii testowej gry, jak wyjaśnia jego pierwsza sekcja. SimulatorService sam podłącza moduł przez require, więc skrypt Main z poradnika nie jest tu potrzebny.
  2. W PlayerData dodaj PowerLevel = 1, i Rebirths = 0, do tabeli DEFAULTS, obok Coins = 0,.
  3. W tym samym module dodaj PowerLevel: number, i Rebirths: number, do typu Data, żeby ścisłe sprawdzanie typów wiedziało o nowych polach.
  4. W SimulatorService zamień local SAVE_PROGRESS = false na local SAVE_PROGRESS = true.

Gracze, którzy zapisali się przed dodaniem pól, dostają je automatycznie: funkcja migrate w PlayerData uzupełnia wszystkie pola z DEFAULTS, których nie ma w zapisanej tabeli, więc zaczynają z Click Power poziomu 1 i 0 rebirthów i zachowują swoje Coins. Jeśli pominiesz punkt 2, SimulatorService wypisze ostrzeżenie z polami, które trzeba dodać, i nie uruchomi gracza.

Dlaczego symulator pisze do tabeli PlayerData

Gdy zapis jest włączony, SimulatorService nigdzie nie kopiuje liczb. PlayerData.Get(player) zwraca żywą tabelę, którą zapisuje moduł, a symulator zmienia Coins, PowerLevel i Rebirths w tej samej tabeli. Każda liczba ma jedną kopię, a do magazynu danych pisze jeden skrypt. Dwa skrypty, które zapisują ten sam klucz, nadpisują się nawzajem i jeden z nich może zapisać stare liczby na liczbach drugiego.

Nie rób też leaderstats w handlerze Loaded, jak poradnik o DataStore radzi dla innych gier: SimulatorService już robi Coins i Rebirths z wczytanej tabeli. Jeśli leaderstats już robi skrypt leaderboardu, usuń go.

Dlaczego nie zapisywać przy każdym kliknięciu

Roblox pozwala każdemu serwerowi na 60 + 40 × gracze zapisów do zwykłego magazynu danych na minutę (reszta jest w tabeli limitów poradnika o DataStore). Zapis przy każdym kliknięciu przy 15 kliknięciach na sekundę to 900 zapisów na minutę na jednego gracza, dużo więcej niż 100, które dostaje serwer z jednym graczem. Zapis całej tabeli co 180 sekund, przy wyjściu gracza i przy wyłączaniu serwera kosztuje tylko kilka zapisów na gracza, a przy awarii ginie najwyżej postęp od ostatniego autozapisu.

Jeśli wczytanie się nie udało, moduł pozwala graczowi grać na nowych liczbach, ale nigdy ich nie zapisuje, więc złe wczytanie nie może nadpisać prawdziwego postępu. Poradnik wyjaśnia, jak moduł to obsługuje.

Dlaczego każdą liczbę decyduje serwer

Exploiterzy kontrolują swoje urządzenie. W poradniku Roblox o bezpieczeństwie napisano, że mogą zmienić cokolwiek w swojej lokalnej kopii gry i wywoływać dowolny RemoteEvent albo RemoteFunction dowolnie wiele razy z dowolnymi argumentami. Ekonomia symulatora jest chroniona dokładnie tak dobrze, jak chroniony jest jego skrypt serwerowy.

Czego może spróbować exploiter i co robi SimulatorService
Exploiter próbujeGdyby decydował klientCo robi SimulatorService
Wywoływać Click w pętli jak najszybciejNieskończone monetyZalicza nie więcej niż 15 kliknięć w każdym oknie sekundowym i ignoruje resztę.
Wysłać liczbę monet razem z kliknięciemSam wybiera sobie nagrodęIgnoruje wszelkie argumenty. Wartość kliknięcia pochodzi z liczb serwera.
Kupić ulepszenie albo rebirth bez potrzebnych monetDarmowe ulepszeniaPorównuje cenę z Coins na serwerze i odpowiada "You need N more coins."
Zmienić Coins w leaderstats na swoim ekranieWydawać monety, których nie maNigdy nie czyta leaderstats. Tylko tam pisze ze swojej tabeli.
Ustawić atrybut PowerLevel na swoim PlayerMocniejsze kliknięcieNigdy nie czyta tego atrybutu, a zmiana zostaje na urządzeniu gracza.
Wywołać Rebirth dwa razy w tej samej chwiliDwa rebirthy w cenie jednegoSprawdza cenę od nowa przy każdym wywołaniu, a między sprawdzeniem a zmianą nic nie oddaje wykonania.
Zmienić ceny w swojej kopii SimulatorConfigTańsze ulepszeniaUżywa własnej kopii modułu.

Zasada działa dla każdego remote’a w symulatorze: wysyłaj to, co gracz chce zrobić, a nie to, ile to kosztuje. W poradniku o RemoteEvent sprawdzanie argumentów remote’ów jest omówione dokładniej.

Czego unikać w skopiowanych skryptach clickerów

Częste sposoby ze starych tutoriali o clickerach i co zamiast nich robi ten poradnik
SposóbProblemTen poradnik
LocalScript dodaje monety przez leaderstats.Coins.Value += 1Zmiana zostaje na jednym urządzeniu, a swoim urządzeniem steruje exploiterMonety dodaje serwer
clickEvent:FireServer(amount)Klient sam wybiera sobie nagrodęClick nie przekazuje argumentów
Brak limitu częstotliwości na serwerzeW dokumentacji Roblox napisano, żeby nigdy nie polegać tylko na limicie na kliencieNie więcej niż 15 kliknięć w każdym oknie sekundowym
SetAsync przy każdym kliknięciu albo ulepszeniuZjada limit zapisów serweraPlayerData zapisuje co 180 sekund, przy wyjściu i przy wyłączaniu. Zapisuj od razu przez PlayerData.SaveNow tylko po czymś, czego nie wolno stracić, na przykład zakupie za Robux.
Drugi skrypt magazynu danych tylko dla symulatoraDwa skrypty, które zapisują jeden klucz, nadpisują się nawzajemPisze do tabeli PlayerData
Pętle while wait(1) do dla pasywnego dochoduRoblox oznacza globalne wait jako przestarzałe, zastępuje je task.waittask.wait (zobacz Jak rozbudować)
MouseButton1Click na przyciskachOpisany dla kliknięć mysząActivated, dla myszy, dotknięć i pada

Krok 5: sprawdź

Przechodź punkty od 1 do 8 z SAVE_PROGRESS = false w SimulatorService, żeby każdy playtest zaczynał się od nowych liczb. Jeśli już włączyłeś zapis w kroku 4, na razie ustaw false, a dla punktu 9 przywróć true.

  1. Kliknij Play. Na górze ekranu jest napis 0 coins, na zielonym przycisku Upgrade: 10, a na pomarańczowym Rebirth: 1.0K.
  2. Kliknij fioletowy przycisk Click! dziesięć razy. Każde kliknięcie pokazuje złote +1, a Coins na liście graczy rośnie o 1.
  3. Kliknij Upgrade. Monety wracają do 0, linia statusu robi się zielona z tekstem "Click Power is now level 2.", a na przycisku jest teraz Upgrade: 15. Od tej chwili każde kliknięcie daje 2 monety.
  4. Nie klikając, kliknij Rebirth. Linia statusu pisze "You need 1000 more coins to rebirth." i nic się nie zmienia.
  5. Żeby sprawdzić rebirth bez 1 000 kliknięć, zatrzymaj test, zmień Coins = 0 na Coins = 1000 w linii pod koniec SimulatorService, która uruchamia nowych graczy, i kliknij Play. Kliknij Rebirth: Coins spadają do 0, Rebirths na liście graczy zmienia się na 1, linia statusu pisze "Rebirth 1! Every click is now worth x2.", a na przycisku jest teraz Rebirth: 3.0K. Każde kliknięcie daje teraz 2 monety na poziomie Click Power 1. Potem przywróć linię na 0.
  6. Żeby zobaczyć limit częstotliwości, ustaw MAX_CLICKS_PER_SECOND w SimulatorConfig na 2 i klikaj szybko. "+N" dalej się pojawiają, ale Coins rosną najwyżej o wartość 2 kliknięć na sekundę. Przywróć 15.
  7. Wybierz telefon w Device Simulator w Studio (to beta Studio; stary Device Emulator też pasuje) i kliknij Play. Sprawdź, czy przycisk Click nie nachodzi ani na licznik monet, ani na przyciski Upgrade i Rebirth i czy linia statusu po kliknięciu Upgrade jest widoczna i nie zasłania jej przycisk.
  8. Podłącz pad albo otwórz Controller Emulator w Studio (Controller na karcie Emulation) w trakcie playtestu, naciśnij Select i sprawdź, czy do trzech przycisków da się dojść i nacisnąć je przez A.
  9. Z włączonym zapisem (krok 4) i znowu SAVE_PROGRESS = true zarób trochę monet, kliknij Stop, a potem znowu Play. Twoje Coins, poziom Click Power i Rebirths wrócą.

Zrób symulator siłowni albo kopalni

Wiele symulatorów zastępuje przycisk akcją w świecie: podnieś hantel, machnij kilofem, machnij mieczem w powietrzu. Pod spodem jest to samo kliknięcie. Tool może wywoływać ten sam remote Click, więc SimulatorService, jego ceny i jego limit częstotliwości zostają bez zmian.

  1. W Explorerze najedź kursorem na StarterPack, wstaw Tool i nazwij go Dumbbell. Wstaw do niego Part o nazwie Handle, nadaj mu kształt hantla i odznacz Anchored, jak w krokach z Toolem z poradnika o mieczu.
  2. Wstaw do Toola LocalScript o nazwie LiftClient i wklej kod poniżej.
  3. Kliknij Play, weź hantel i klikaj. Monety rosną o twój Click Power za każde podniesienie, dokładnie jak z przyciskiem.
LocalScript w Tool Dumbbell w StarterPack o nazwie LiftClient
-- LocalScript w Tool Dumbbell o nazwie LiftClient.
-- Każde podniesienie to kliknięcie: wywołuje ten sam remote Click co przycisk, a serwer
-- decyduje, ile jest warte i ile podniesień zaliczyć.

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 -- czas między podniesieniami na tym urządzeniu; serwer ma własny limit
local LIFT_ANIMATION_ID = "" -- opcjonalnie: "rbxassetid://", a po nim id twojej animacji

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

-- Wczytujemy animację podnoszenia raz na postać, przez Animator, który Roblox wkłada do Humanoid
local function loadLift()
	local character = player.Character
	if LIFT_ANIMATION_ID == "" or not character or character == trackCharacter then
		return
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	local animator = humanoid and humanoid:FindFirstChildOfClass("Animator")
	if animator then
		local animation = Instance.new("Animation")
		animation.AnimationId = LIFT_ANIMATION_ID
		liftTrack = animator:LoadAnimation(animation)
		trackCharacter = character
	end
end

tool.Equipped:Connect(loadLift)

tool.Activated:Connect(function()
	local now = os.clock()
	if now - lastLift < LIFT_SECONDS then
		return
	end
	lastLift = now
	if liftTrack then
		liftTrack:Play()
	end
	clickEvent:FireServer() -- bez argumentów: nagrodę liczy serwer
end)

Dla animacji podnoszenia zrób ją w Animation Editor z priorytetem Action, opublikuj i wstaw jej ID do LIFT_ANIMATION_ID. Kroki z animacją z poradnika o mieczu działają tak samo.

  • Dopasuj limit serwera do akcji. LIFT_SECONDS spowalnia tylko uczciwych graczy: oszust może wywoływać Click ze swojego kodu. Jeśli podnoszenie to jedyny sposób zarabiania, obniż MAX_CLICKS_PER_SECOND w SimulatorConfig do realnego tempa, na przykład do 2 przy jednym podniesieniu co 0.5 sekundy, żeby skrypt nie mógł zarobić więcej niż gracz. Potem przelicz tabelę tempa: każdy czas w niej jest liczony na 5 kliknięć na sekundę.
  • Zostaw albo schowaj przycisk. Przycisk Click dalej działa obok Toola. Żeby go schować, dodaj clickButton.Visible = false zaraz po linii w SimulatorClient, która tworzy clickButton.
  • Zarabianie tylko we właściwym miejscu. Żeby płacić tylko w siłowni albo w kopalni, sprawdzaj na serwerze, gdzie jest postać, zanim zaliczysz kliknięcie, na przykład po odległości do partu w tej strefie. Sprawdzenie w LiftClient nikogo by nie zatrzymało.

Co dalej: kolejność budowy symulatora

Symulator to stos systemów na tej pętli. Buduj je w tej kolejności, żeby każdy miał co mnożyć, i rób playtest po każdym. Oto kolejność, którą radzimy, z poradnikiem dla każdego kroku.

Kolejność budowy symulatora w Roblox, od głównej pętli na zewnątrz
KolejnośćSystemPoradnikDlaczego właśnie teraz
1Zarabianie, ulepszenie, rebirthTen poradnikWszystko inne mnoży tę pętlę, więc najpierw ustaw jej liczby według tabeli tempa.
2ZapisPoradnik o DataStore, potem krok 4Postęp, który resetuje się przy ponownym wejściu, zabija symulator. Dodaj go przed wszystkim, co gracze mogą stracić.
3Jajka i pety jako mnożnikiOtwieranie jajek i pety, które chodzą za graczemDrugi cel obok monet: coś, co można zbierać i co sprawia, że każde kliknięcie jest więcej warte.
4Strefy za rebirthamiJak rozbudowaćDokąd iść po rebirthcie, z lepszymi nagrodami, które sprawdza serwer.
5LeaderboardyPoradnik o leaderboardzieGlobalne top 10 według rebirthów nadaje sens długiej wspinaczce.
6Codzienne nagrody i kodyCodzienne nagrody i kodyPowody, żeby wrócić jutro i po każdej aktualizacji.
7Game passyPoradnik o game passach2x monet, autoklik albo dodatkowy slot na peta, ze sprawdzaniem na serwerze. Sprzedawaj je, gdy darmowa pętla jest już ciekawa.

Do ekranów darmowe zestawy UI do Roblox zawierają ekrany w stylu symulatorów razem ze skryptami, które sprawiają, że działają.

Jak zrobić symulator bez pisania skryptów

Symulator i tak potrzebuje skryptów: ktoś musi dodawać monety, sprawdzać ceny i zapisywać. Pisać ich samemu nie trzeba:

  • Zestaw symulatora z Creator Store. Przeczytaj jego skrypty przed publikacją i sprawdź, czy monety zmieniają się tylko w serwerowym Script, a nie w LocalScript.
  • Plugin-generator symulatorów. To samo sprawdzenie dla wszystkiego, co tworzy.
  • Agent AI w Studio, na przykład RoCode, który może zbudować te same trzy skrypty w grze, którą masz otwartą.
  • Build w aplikacji mobilnej Roblox. Według dokumentacji Roblox robi z opisu prostsze gry 2D i 2.5D, na przykład clickery, i wychodzi stopniowo w kolejnych regionach.

Cokolwiek wybierzesz, przepuść wynik przez sprawdzenia z kroku 5 i sprawdzenia pod kątem exploitów z sekcji Dlaczego każdą liczbę decyduje serwer.

Jak rozbudować: pety, strefy, autoklik i leaderboardy

Pety jako mnożniki

Częsty wariant: każdy pet to mnożnik. Trzymaj listę id petów gracza w jego zapisanej tabeli, a serwer niech mnoży clickValue przez bonus każdego założonego peta. Otwieraj jajka na serwerze: klient prosi o otwarcie jajka, serwer sprawdza i zabiera cenę, a potem wybiera peta ważonym losowaniem. Nigdy nie pozwalaj klientowi losować za jajko ani mówić, jaki pet wypadł. Poradnik o ekwipunku pokazuje, jak przechowywać, zapisywać i pokazywać przedmioty gracza, a pety działają tak samo. Poradnik o otwieraniu jajek buduje losowanie na serwerze, a poradnik o petach sprawia, że pety latają obok właściciela.

Strefy, które otwierają rebirthy

Strefa to część mapy z lepszymi nagrodami za barierą. Blokuj nagrodę, a nie tylko drzwi: wszystko, co płaci w strefie, musi sprawdzić Rebirths gracza w tabeli serwera, zanim zapłaci. Drzwi, które LocalScript otwiera pasującym graczom, nadają się dla wyglądu, ale exploiterzy mogą zmieniać party i przesuwać swoją postać na swoim urządzeniu.

Autoklik jako game pass

Autoclicker sprzedawany jako game pass musi działać na serwerze. Przenieś ciało handlera Click do funkcji, na przykład addClick(player), podłącz do niej remote, a dla właścicieli passa wywołuj ją z serwerowej pętli z task.wait(0.5), a nie z przestarzałym wait. Wtedy autokliki wchodzą w ten sam limit na sekundę co zwykłe kliknięcia. Sprawdzaj posiadanie na serwerze przez MarketplaceService:UserOwnsGamePassAsync, jak robi poradnik o game passach dla swoich bonusów. Pass 2x monet działa tak samo: mnóż clickValue na serwerze dla właścicieli. Zanim ustalisz cenę, darmowy kalkulator podatku od Robux pokaże, ile przynosi ci każda sprzedaż po udziale Roblox, a kalkulator DevEx pokaże, ile te Robux są warte w dolarach amerykańskich.

Globalne top 10 według rebirthów

leaderstats porównuje tylko graczy na jednym serwerze. Żeby rankingować Rebirths wszystkich graczy, zapisuj je w uporządkowanym magazynie danych (ordered data store) i czytaj z powrotem najwyższe wpisy, jak w kroku 4 poradnika o leaderboardzie. Uporządkowane magazyny pozwalają na mniej zapisów niż zwykłe, 30 + 5 × gracze na minutę na serwer, więc zapisuj przy wyjściu gracza i według timera.

Bardzo duże liczby

Liczby w Luau to double, przechowują około 15 cyfr znaczących. IntValue przechowuje liczby całkowite do około 9.2 tryliona, ale Roblox ostrzega, że wartości większe niż 2^53 (około 9 biliardów) tracą dokładność w skryptach. Z tymi ustawieniami cena rebirtha przekracza tę granicę na 29. rebirthcie. Jeśli twoja gra idzie dalej, przestaw wartości leaderstats na NumberValue (zamień IntValue w obu skryptach), który przechowuje dużo większe liczby z tą samą dokładnością około 15 cyfr, i dodaj sufiksy do short().

Na czym opiera się gra-symulator

Symulator to gra liczb. Kliknięcie, ulepszenie i rebirth wyżej to cała pętla; czy gracze zostaną, decyduje to, jak rosną te liczby. Co kilka minut gracz powinien móc sobie pozwolić na coś, co przyspieszy kolejne kilka minut, a każda sesja powinna kończyć się blisko celu, dla którego chce się wrócić.

  • Wzrost, który starcza na długo. Ceny ulepszeń rosną szybciej niż dochód, więc każdy stopień zajmuje trochę więcej czasu. Rebirth resetuje monety dla stałego mnożnika, a stara strefa staje się szybka i wspinaczka wydaje się nowa.
  • Co zbierać. Strefy do otwarcia, pety z jajek, które mnożą zarobki, i narzędzia do ulepszania dają graczom listę celów poza jedną liczbą.
  • Duże liczby, które zostają czytelne. Pokazuj 1.5M, a nie 1500000, i przechowuj liczby tak, żeby serwer mógł je porównywać, nawet gdy robią się duże.

Monetyzacja, która pasuje do symulatora

Częste passy mnożą monety, dają dodatkowy slot na peta, otwierają więcej jajek naraz albo włączają autoklik. Sprzedawaj je jako game passy i sprawdzaj na serwerze. Paczki monet to developer products. Jeśli jajka albo cokolwiek z losowym wynikiem można kupić za Robux albo za walutę kupioną za Robux, Roblox wymaga pokazywania szans przed zakupem: przeczytaj paid random items (po angielsku), zanim zbudujesz sklep.

Co sprawia, że gracze wracają

Zapisany postęp, nowa strefa albo zestaw petów w aktualizacjach, codzienne nagrody, kody ogłaszane razem z aktualizacjami i leaderboard według rebirthów. Inne gatunki, każdy z własną pętlą, systemami i planem budowy: gatunki gier w Roblox.

Częste błędy i rozwiązania

Otwórz okno Output (menu Window, potem Output) przed kliknięciem Play. Większość problemów wypisuje tam ostrzeżenie albo błąd z nazwą skryptu i linią.

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

LocalScript czeka na remote’y, które SimulatorService tworzy przy starcie. Sprawdź, czy SimulatorService to Script, a nie LocalScript, czy leży w ServerScriptService i czy w Output nie ma od niego błędu. Takie samo ostrzeżenie dla SimulatorConfig znaczy, że modułu nie ma w ReplicatedStorage albo nazywa się inaczej.

Przyciski się nie pojawiają

LocalScript czeka na twoje leaderstats, zanim zbuduje ekran. Jeśli w Output jest Infinite yield possible na leaderstats, SimulatorService jeszcze cię nie uruchomił. Z SAVE_PROGRESS = true czeka na PlayerData, więc sprawdź, czy PlayerData leży w ServerScriptService i wczytuje się bez błędów.

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

Zapis jest włączony, ale moduł PlayerData nie ma jeszcze nowych pól. Dodaj je do jego DEFAULTS, jak w kroku 4, i znowu kliknij Play.

"+1" wyskakują, ale monety nie rosną

Serwer nie zalicza kliknięć. Albo w SimulatorService jest błąd (szukaj czerwonego tekstu od niego w Output), albo kliknięcia przychodzą szybciej, niż pozwala MAX_CLICKS_PER_SECOND. Jeśli gracze dochodzą do limitu przy zwykłej grze, podnieś go w SimulatorConfig.

Linia statusu pisze "No answer from the server. Try again."

Wywołanie BuyUpgrade albo Rebirth się wywaliło, zamiast zwrócić odpowiedź. Zwykła przyczyna to błąd w SimulatorService podczas obsługi żądania, więc szukaj od niego czerwonego błędu w Output: jest tam podana linia.

Licznik monet na ekranie i lista graczy pokazują różne liczby

Jeszcze jeden skrypt też robi folder leaderstats, więc każdy gracz ma dwa, a LocalScript może czytać inny. Usuń zbędny skrypt: SimulatorService sam robi Coins i Rebirths.

Monety resetują się przy każdym ponownym wejściu

Zapis jest wyłączony. Przejdź krok 4. Jeśli jest włączony, a monety w Studio i tak się resetują, sprawdź, czy w kopii testowej jest włączony dostęp Studio do API services, jak wyjaśnia poradnik o DataStore.

Zrób to z RoCode

Jeśli nie chce ci się wklejać tego ręcznie, RoCode może to zbudować w grze, którą masz otwartą. To niezależny agent AI do kodu, nie od Roblox: opisujesz system na jego czacie w przeglądarce, a jego plugin do Roblox Studio tworzy skrypty w twoim Explorerze, więc nie musisz kopiować kodu z okna czatu.

Ty piszesz

Zrób symulator clickera: duży przycisk Click, który daje monety równe mojemu poziomowi Click Power razy (rebirthy + 1), przycisk Upgrade, który kosztuje 10 monet i drożeje 1.5 raza z każdym poziomem, i przycisk Rebirth za 1 000 monet, który resetuje monety i ulepszenia. Trzymaj liczby na serwerze i ogranicz kliknięcia do 15 na sekundę. Mam już moduł PlayerData.

RoCode robi
  • Może najpierw przeczytać twój moduł PlayerData i każdy skrypt leaderstats przez Search Scripts i Read Script, żeby dodać pola do twoich istniejących danych, zamiast pisać drugi skrypt zapisu
  • Może zrobić szkielet ekranu przez układ HUD z Build UI (z pluginem 3.9 lub nowszym, w stylu symulatora) albo zbudować przyciski w LocalScript, i pisze ModuleScript, serwerowy Script i LocalScript przez Create Script
  • Ma polecone sprawdzać kompilację każdego napisanego skryptu przez Check Script, który kompiluje go w Studio bez uruchamiania
  • Stawia punkt cofania przed i po każdej paczce zmian, więc Ctrl+Z cofa po jednej paczce

RoCode nie może tworzyć game passów ani developer products ani wgrywać meshy i ikon petów: robi się to w Creator Hub i Studio. Z pluginem 3.9.11 lub nowszym RoCode może uruchamiać playtest twojej gry w Studio i sterować testową postacią, żeby sprawdzić, czy wszystko działa, a z pluginem 3.9.15 lub nowszym testowa postać może klikać przyciski na ekranie, na przykład kliknąć Click i sprawdzić, czy Coins urosły. Sam decyduje, kiedy uruchomić playtest, do 2 na budowę plus 1 do sprawdzenia swojej poprawki, i sprawdza tylko to, co wybrał, więc pętlę sprawdź sam. Cały symulator to kilka promptów, po jednym systemie naraz: jak z RoCode budować po jednym systemie na prompt. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Jak zrobić symulator w Roblox bez skryptów?

Działający symulator potrzebuje skryptów: ktoś musi dodawać monety, sprawdzać ceny i zapisywać postęp. Możesz wkleić trzy skrypty z tego poradnika bez zmian i zmieniać tylko liczby w SimulatorConfig albo pozwolić zrobić je zestawowi z Creator Store, pluginowi albo agentowi AI i sprawdzić, czy o monetach decyduje serwer. Opcje.

Jak działa system rebirthów?

Rebirth wymienia twoje monety i ulepszenia na stały bonus. W tym poradniku pierwszy rebirth kosztuje 1 000 monet; ustawia Coins na 0, Click Power na poziom 1 i dodaje 1 do Rebirths, a dalej każde kliknięcie jest mnożone przez Rebirths + 1. Każdy rebirth kosztuje trzy razy więcej niż poprzedni.

Jak zrobić symulator siły albo siłowni?

Daj graczom Tool, na przykład hantel, którego LocalScript wywołuje ten sam remote Click przy Tool.Activated. Serwer liczy nagrodę dokładnie tak samo jak za kliknięcie przycisku. Obniż serwerowy limit kliknięć do tempa podnoszenia, żeby skrypt nie mógł zarobić więcej niż gracz. Skrypt jest w sekcji wersja z hantlem.

Jakie systemy są potrzebne w symulatorze?

Najpierw pętla zarabiania, ulepszeń i rebirthów, potem zapis, potem pety albo inna kolekcja, która mnoży zarobki, strefy za rebirthami, leaderboardy, codzienne nagrody i kody, a na samym końcu game passy. W kolejności budowy jest poradnik dla każdego.

Ile powinien trwać rebirth?

Na tyle długo, żeby gracze najpierw kupili kilka ulepszeń, i na tyle krótko, żeby w pierwszej sesji dojść do jednego. Z liczbami tego poradnika pierwszy rebirth przychodzi po około 1.2 minuty przy 5 kliknięciach na sekundę; jeśli podniesiesz REBIRTH_BASE_COST do 10 000, będzie około 8 minut. Więcej ustawień w tabeli tempa.

Jak chronić się przed autoclickerami?

Serwer zalicza nie więcej niż 15 kliknięć na gracza w każdym oknie sekundowym i ignoruje resztę. Poniżej tego limitu skrypt wygląda tak samo jak szybki gracz, więc ekonomię chroni właśnie limit. Możesz też sprzedawać autoklik jako game pass, który działa na serwerze.

Dlaczego monety resetują się przy ponownym wejściu?

Na razie nic ich nie zapisuje. Dodaj moduł PlayerData z poradnika o DataStore, dodaj PowerLevel i Rebirths do jego DEFAULTS i ustaw SAVE_PROGRESS = true w SimulatorService, jak w kroku 4.

Jak dodać pety do symulatora?

Zrób każdego peta mnożnikiem, który serwer stosuje do kliknięć. Otwieraj jajka na serwerze z ważonym losowym wyborem, zapisuj id petów gracza razem z resztą jego danych i pokazuj je w GUI ekwipunku, jak w poradniku o ekwipunku.

Co lepsze: klikanie partu czy przycisku?

Pasuje jedno i drugie. Przycisk na ekranie jest wygodny na telefonach, a part z ClickDetector pasuje do gry, w której wszystko dzieje się w świecie. Według dokumentacji Roblox serwer w ogóle nie sprawdza eventów ClickDetector, więc ograniczaj częstotliwość tych kliknięć na serwerze w ten sam sposób.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.