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
Jak zbudowana jest główna pętla symulatora
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.
| Akcja | Ile kosztuje | Co daje | Kto decyduje |
|---|---|---|---|
| Kliknięcie | Nic | Monety równe Click Power × (Rebirths + 1) | Serwer, który zalicza nie więcej niż 15 kliknięć w każdym oknie trwającym sekundę |
| Ulepszenie | 10 monet, dalej 1.5 raza więcej niż poprzednia cena za każdy poziom | Kolejny poziom Click Power, do 50. | Serwer, według swojej kopii cen |
| Rebirth | 1 000 monet, dalej 3 razy więcej niż poprzednia cena za każdy rebirth | Monety z powrotem na 0 i Click Power z powrotem na poziom 1, plus stałe +1 do mnożnika | Serwer |
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ć.
| Element | Gdzie jest | Co robi |
|---|---|---|
ModuleScript SimulatorConfig | ReplicatedStorage | Ceny, limity i wzory na wartość kliknięcia, cenę ulepszenia i cenę rebirtha. Czytają go obie strony. |
Script SimulatorService | ServerScriptService | Przechowuje liczby każdego gracza, obsługuje kliknięcia, ulepszenia i rebirthy i wypełnia leaderstats. |
Folder SimulatorRemotes | ReplicatedStorage (tworzy go SimulatorService) | RemoteEvent Click i RemoteFunction BuyUpgrade i Rebirth. |
LocalScript SimulatorClient | StarterPlayerScripts | Buduje przyciski, wysyła kliknięcia i żądania i pokazuje liczby serwera. |
ModuleScript PlayerData (opcjonalnie) | ServerScriptService | Zapisuje postęp między wejściami. Pochodzi z poradnika o DataStore i jest potrzebny tylko 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.
- W Explorerze najedź kursorem na ReplicatedStorage, kliknij przycisk + i wstaw ModuleScript.
- Zmień jego nazwę na
SimulatorConfig(nazwy rozróżniają wielkość liter) i zastąp jego zawartość kodem poniżej.
-- 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.
| Poziom Click Power | Cena następnego poziomu | Monet za kliknięcie, bez rebirthów | Monet za kliknięcie, 1 rebirth |
|---|---|---|---|
| 1 | 10 | 1 | 2 |
| 2 | 15 | 2 | 4 |
| 3 | 22 | 3 | 6 |
| 4 | 33 | 4 | 8 |
| 5 | 50 | 5 | 10 |
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.
REBIRTH_BASE_COST | Rebirth 1 | Rebirth 2 | Rebirth 3 |
|---|---|---|---|
| 1 000 (ten poradnik) | 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 |
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:
-- 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.
- W Explorerze rozwiń StarterPlayer, najedź kursorem na StarterPlayerScripts i wstaw LocalScript o nazwie
SimulatorClient. - Zastąp jego zawartość kodem poniżej i kliknij Play.
-- 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,
UIAspectRatioConstrainttrzyma go kwadratowym, aUISizeConstraintogranicza 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 doUNITS.- 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.
- Przejdź krok 1 poradnika o DataStore, żeby dodać ModuleScript
PlayerDatado 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 skryptMainz poradnika nie jest tu potrzebny. - W PlayerData dodaj
PowerLevel = 1,iRebirths = 0,do tabeliDEFAULTS, obokCoins = 0,. - W tym samym module dodaj
PowerLevel: number,iRebirths: number,do typuData, żeby ścisłe sprawdzanie typów wiedziało o nowych polach. - W SimulatorService zamień
local SAVE_PROGRESS = falsenalocal 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.
| Exploiter próbuje | Gdyby decydował klient | Co robi SimulatorService |
|---|---|---|
| Wywoływać Click w pętli jak najszybciej | Nieskończone monety | Zalicza nie więcej niż 15 kliknięć w każdym oknie sekundowym i ignoruje resztę. |
| Wysłać liczbę monet razem z kliknięciem | Sam wybiera sobie nagrodę | Ignoruje wszelkie argumenty. Wartość kliknięcia pochodzi z liczb serwera. |
| Kupić ulepszenie albo rebirth bez potrzebnych monet | Darmowe ulepszenia | Porównuje cenę z Coins na serwerze i odpowiada "You need N more coins." |
| Zmienić Coins w leaderstats na swoim ekranie | Wydawać monety, których nie ma | Nigdy nie czyta leaderstats. Tylko tam pisze ze swojej tabeli. |
| Ustawić atrybut PowerLevel na swoim Player | Mocniejsze kliknięcie | Nigdy nie czyta tego atrybutu, a zmiana zostaje na urządzeniu gracza. |
| Wywołać Rebirth dwa razy w tej samej chwili | Dwa rebirthy w cenie jednego | Sprawdza cenę od nowa przy każdym wywołaniu, a między sprawdzeniem a zmianą nic nie oddaje wykonania. |
| Zmienić ceny w swojej kopii SimulatorConfig | Tańsze ulepszenia | Uż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
| Sposób | Problem | Ten poradnik |
|---|---|---|
LocalScript dodaje monety przez leaderstats.Coins.Value += 1 | Zmiana zostaje na jednym urządzeniu, a swoim urządzeniem steruje exploiter | Monety dodaje serwer |
clickEvent:FireServer(amount) | Klient sam wybiera sobie nagrodę | Click nie przekazuje argumentów |
| Brak limitu częstotliwości na serwerze | W dokumentacji Roblox napisano, żeby nigdy nie polegać tylko na limicie na kliencie | Nie więcej niż 15 kliknięć w każdym oknie sekundowym |
SetAsync przy każdym kliknięciu albo ulepszeniu | Zjada limit zapisów serwera | PlayerData 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 symulatora | Dwa skrypty, które zapisują jeden klucz, nadpisują się nawzajem | Pisze do tabeli PlayerData |
Pętle while wait(1) do dla pasywnego dochodu | Roblox oznacza globalne wait jako przestarzałe, zastępuje je task.wait | task.wait (zobacz Jak rozbudować) |
MouseButton1Click na przyciskach | Opisany 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.
- Kliknij Play. Na górze ekranu jest napis 0 coins, na zielonym przycisku Upgrade: 10, a na pomarańczowym Rebirth: 1.0K.
- Kliknij fioletowy przycisk Click! dziesięć razy. Każde kliknięcie pokazuje złote +1, a Coins na liście graczy rośnie o 1.
- 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.
- Nie klikając, kliknij Rebirth. Linia statusu pisze "You need 1000 more coins to rebirth." i nic się nie zmienia.
- Żeby sprawdzić rebirth bez 1 000 kliknięć, zatrzymaj test, zmień
Coins = 0naCoins = 1000w 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. - Żeby zobaczyć limit częstotliwości, ustaw
MAX_CLICKS_PER_SECONDw SimulatorConfig na 2 i klikaj szybko. "+N" dalej się pojawiają, ale Coins rosną najwyżej o wartość 2 kliknięć na sekundę. Przywróć 15. - 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.
- 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.
- Z włączonym zapisem (krok 4) i znowu
SAVE_PROGRESS = truezaró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.
- W Explorerze najedź kursorem na StarterPack, wstaw Tool i nazwij go
Dumbbell. Wstaw do niego Part o nazwieHandle, nadaj mu kształt hantla i odznacz Anchored, jak w krokach z Toolem z poradnika o mieczu. - Wstaw do Toola LocalScript o nazwie
LiftClienti wklej kod poniżej. - 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 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_SECONDSspowalnia tylko uczciwych graczy: oszust może wywoływać Click ze swojego kodu. Jeśli podnoszenie to jedyny sposób zarabiania, obniżMAX_CLICKS_PER_SECONDw 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 = falsezaraz po linii w SimulatorClient, która tworzyclickButton. - 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ść | System | Poradnik | Dlaczego właśnie teraz |
|---|---|---|---|
| 1 | Zarabianie, ulepszenie, rebirth | Ten poradnik | Wszystko inne mnoży tę pętlę, więc najpierw ustaw jej liczby według tabeli tempa. |
| 2 | Zapis | Poradnik o DataStore, potem krok 4 | Postęp, który resetuje się przy ponownym wejściu, zabija symulator. Dodaj go przed wszystkim, co gracze mogą stracić. |
| 3 | Jajka i pety jako mnożniki | Otwieranie jajek i pety, które chodzą za graczem | Drugi cel obok monet: coś, co można zbierać i co sprawia, że każde kliknięcie jest więcej warte. |
| 4 | Strefy za rebirthami | Jak rozbudować | Dokąd iść po rebirthcie, z lepszymi nagrodami, które sprawdza serwer. |
| 5 | Leaderboardy | Poradnik o leaderboardzie | Globalne top 10 według rebirthów nadaje sens długiej wspinaczce. |
| 6 | Codzienne nagrody i kody | Codzienne nagrody i kody | Powody, żeby wrócić jutro i po każdej aktualizacji. |
| 7 | Game passy | Poradnik o game passach | 2x 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.
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.
- 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
- Roblox Creator Docs: Securing the client-server boundary (po angielsku). limit częstotliwości, przykład sklepu w grze i eventy ClickDetector
- Roblox Creator Docs: Security and cheat mitigation tactics (po angielsku). czym exploiter steruje na swoim urządzeniu
- Roblox Creator Docs: Remote events and callbacks (po angielsku). FireServer, parametr gracza, InvokeServer i OnServerInvoke
- Roblox Creator Docs: Leaderboards (po angielsku). leaderstats i uporządkowane magazyny danych
- Roblox Creator Docs: Data store error codes and limits (po angielsku). limity zapisów na serwer dla zwykłych i uporządkowanych magazynów danych
- Roblox Engine API: GuiButton (po angielsku). Activated na komputerze, telefonie i konsoli
- Roblox Engine API: GuiService (po angielsku). AutoSelectGuiEnabled i zaznaczanie obiektów GUI padem
- Roblox Engine API: IntValue (po angielsku). 64-bitowy zakres i utrata dokładności powyżej 2^53
- Roblox Creator Docs: Size modifiers and constraints (po angielsku). UIAspectRatioConstraint i UISizeConstraint
- Roblox Creator Docs: Studio testing modes (po angielsku). Device Simulator i Controller Emulator
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ą.