教程 · 游戏系统

Roblox 怎么做模拟器游戏

几乎所有模拟器都围绕同一个循环运转:做一件简单的事赚取货币,把货币花在让你赚得更快的升级上,然后重生(rebirth),带着永久倍率从头再来。本教程把这个循环做成一个由三个脚本组成的点击游戏,每个数字都由服务端决定,并用 DataStore 教程中的 PlayerData 模块保存进度。如果你从没在 Studio 里做过游戏,请先做一条简短的金币赛道。

更新于 2026年11月20日阅读约 6 分钟作者

要点

Roblox 模拟器就是一个循环:点击获得金币,把金币花在能赚更多的升级上,然后重生换取永久倍率。把价格放在 ReplicatedStorage 中的 ModuleScript 里。ServerScriptService 中的一个 Script 保存每个玩家的 Coins、Click Power 和 Rebirths,每秒最多接受来自 RemoteEvent Click 的 15 次点击,并在检查价格后通过 RemoteFunction 出售升级和重生。LocalScript 显示 Click、Upgrade 和 Rebirth 按钮。按本教程的数字,每秒点击 5 次的玩家大约 1.2 分钟就能第一次重生,节奏表说明要改什么才能让成长更久。

  • 点击只传递点击这件事本身。它值多少由服务端计算,所以被修改过的客户端无法给自己加金币。
  • 按定时器和玩家离开时保存整张表,而不是每次点击都保存。Roblox 允许每个服务器每分钟向数据存储写入 60 + 40 × 玩家数 次。
  • 不会写脚本?Creator Store 的套件、插件或 AI 代理也能搭出同样的循环。请确认金币由服务端决定:可选方案。
  • 想要健身房或矿洞,而不是按钮?Tool 可以调用同一个 Click 远程事件:哑铃版本。然后按下面的构建顺序添加系统。
本页内容
  1. 工作原理
  2. 1. 配置模块
  3. 2. 服务端脚本
  4. 3. 按钮
  5. 4. 存档
  6. 为什么由服务端决定
  7. 5. 测试
  8. 哑铃版本
  9. 构建顺序
  10. 不写脚本
  11. 如何扩展
  12. 游戏类型
  13. Common errors
  14. 使用 RoCode
  15. 常见问题
  16. 参考资料

模拟器的核心循环是怎样的

示意图玩家花 10 枚金币买下 2 级 Click Power,然后(加速播放)攒到 1,000 枚金币并重生:金币和升级被清零,而每次点击变为 x2。

模拟器是由三个动作组成的循环。玩家一遍遍做一件简单的事来赚货币,把货币花在让自己赚得更快的升级上,当升级变贵时就重生:交出金币和升级,换取一个永久保留的加成,然后再次成长,而且更快。其他模拟器用举哑铃、挖矿或收集物品代替点击,但底下的循环是一样的。

本教程循环中的三个动作
动作花费得到谁来决定
点击无金币,等于 Click Power × (Rebirths + 1)服务端,在每个一秒长的窗口内最多计入 15 次点击
升级10 枚金币,之后每级是上一个价格的 1.5 倍再加一级 Click Power,最高 50 级服务端,按它自己的那份价格
重生1,000 枚金币,之后每次是上一个价格的 3 倍金币回到 0,Click Power 回到 1 级,外加永久 +1 倍率服务端

每个数字都存在服务端。玩家的设备负责画按钮并提出请求(“我点了一下”,“我想升级”),由服务端决定它值多少、能不能做。被人破解的点击脚本,常常是在 LocalScript 里加金币,或者让客户端发送要加多少金币。

模拟器由哪些部分组成
组件位置作用
ModuleScript SimulatorConfigReplicatedStorage价格、上限,以及点击价值、升级价格和重生价格的公式。两端都会读取它。
Script SimulatorServiceServerScriptService保存每个玩家的数字,处理点击、升级和重生,并填写 leaderstats。
Folder SimulatorRemotesReplicatedStorage(由 SimulatorService 创建)RemoteEvent Click,以及 RemoteFunction BuyUpgrade 和 Rebirth。
LocalScript SimulatorClientStarterPlayerScripts创建按钮,发送点击和请求,并显示服务端的数字。
ModuleScript PlayerData(可选)ServerScriptService在多次进入游戏之间保存进度。它来自 DataStore 教程,只在第 4 步需要。
游戏运行时的 Explorer。SimulatorService 在游戏启动时创建 SimulatorRemotes 和三个远程对象,PlayerData 只有在第 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

第 1 步:把价格和公式放进模块

每个你可能想调整的数字都放进一个 ModuleScript:点击值多少、每次升级和重生多少钱,以及点击上限。服务端按它做决定,LocalScript 从它那里取价格显示在按钮上,所以任何修改都只需在一个地方改一处。

  1. 在 Explorer 中把鼠标悬停在 ReplicatedStorage 上,点击 + 按钮,插入一个 ModuleScript。
  2. 把它重命名为 SimulatorConfig(名称区分大小写),并用下面的代码替换它的内容。
ModuleScript 位置: ReplicatedStorage 名称: SimulatorConfig
-- 核心循环的所有数字,以及两端都使用的公式。客户端只用它们
-- 显示价格;服务端按它自己的那份副本做决定。

local SimulatorConfig = {}

SimulatorConfig.UPGRADE_BASE_COST = 10 -- 2 级 Click Power 的价格
SimulatorConfig.UPGRADE_COST_GROWTH = 1.5 -- 每一级的价格是上一级的 1.5 倍
SimulatorConfig.MAX_POWER_LEVEL = 50
SimulatorConfig.REBIRTH_BASE_COST = 1000 -- 第一次重生所需的金币
SimulatorConfig.REBIRTH_COST_GROWTH = 3 -- 每次重生的价格是上一次的 3 倍
SimulatorConfig.MAX_CLICKS_PER_SECOND = 15 -- 一秒内超过这个数的点击会被忽略

-- 每次点击的金币:Click Power 等级乘以 1 + 重生次数
function SimulatorConfig.clickValue(powerLevel: number, rebirths: number): number
	return powerLevel * (rebirths + 1)
end

-- 下一级 Click Power 的价格
function SimulatorConfig.upgradeCost(powerLevel: number): number
	return math.floor(SimulatorConfig.UPGRADE_BASE_COST * SimulatorConfig.UPGRADE_COST_GROWTH ^ (powerLevel - 1))
end

-- 下一次重生所需的金币
function SimulatorConfig.rebirthCost(rebirths: number): number
	return SimulatorConfig.REBIRTH_BASE_COST * SimulatorConfig.REBIRTH_COST_GROWTH ^ rebirths
end

return SimulatorConfig

玩家可以读取 ReplicatedStorage 中的 ModuleScript,所以这些价格是公开的。这没关系:它们本来就写在按钮上。客户端和服务端各自运行自己的一份模块,所以在自己设备上改数字的玩家改变不了服务端的任何东西。

按这些设置,公式给出的结果
Click Power 等级下一级价格每次点击金币,无重生每次点击金币,1 次重生
11012
21524
32236
43348
550510

重生的价格是 1,000 枚金币,然后 3,000,然后 9,000,因为 rebirthCost 每次都把价格乘以 3。重生一次后,每次点击的价值翻倍,两次后变为三倍,依此类推。

按这些数字,一次重生要多久

公式决定循环持续多久,所以最好在玩家之前先把数字算清楚。下表假设玩家一付得起重生就马上重生,其余时间只要付得起下一级 Click Power、且它比重生便宜,就买下它。时间从全新开始算起,所以最后一列是到第 3 次重生的总时间。

每秒点击 5 次时,从全新开始到每次重生所需的分钟数,按 REBIRTH_BASE_COST 区分。根据 SimulatorConfig 的公式计算,并非在玩家身上实测
REBIRTH_BASE_COST重生 1重生 2重生 3
1,000(本教程)1.22.74.8
5,0004.310.118.3
10,0008.216.933.2
25,00016.740.174.5
50,00032.868.8137.8

不重生的话,Click Power 5 级在 34 次点击后到来,10 级在 122 次后,13 级在 285 次后。按默认数字,玩家之后就不再升级了,因为 14 级要 1,297 枚金币,比 1,000 枚金币的重生还贵,第一次重生总共在 362 次点击后到来。在服务端每秒 15 次点击的上限下,每个时间都除以 3。改动 SimulatorConfig 中的任何数字,这些时间都会随之变化,所以请重新计算。

调整增长

两个 _GROWTH 数字决定价格涨得多快。设为 1.5 时,每次升级的价格是前一次的 1.5 倍,而每一级每次点击只多一枚金币(在重生倍率之前),所以每个新等级回本的时间越来越长。正是这种放缓让重生变得划算。想让成长更久就调高增长,想更快就调低,并让 REBIRTH_BASE_COST 足够高,使玩家在第一次重生前能买几次升级。

想让第一次重生在几分钟后而不是大约一分钟后到来,就把 REBIRTH_BASE_COST 提高到 5,000 或 10,000。

第 2 步:添加服务端脚本

这个 Script 掌管每一个数字。它创建远程对象,给每个玩家一个包含 Coins 和 Rebirths 的 leaderstats 文件夹,并响应三种请求。把鼠标悬停在 ServerScriptService 上,插入一个 Script,重命名为 SimulatorService,并用下面的代码替换内容:

Script 位置: ServerScriptService 名称: SimulatorService
-- 掌管每一个数字:点击在这里换成金币,升级和重生在这里购买,
-- 而 leaderstats 只负责显示结果。

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

-- false:每次进入时所有人从零开始。true:通过 DataStore 教程中的 PlayerData 模块
-- 加载和保存(先在它的 DEFAULTS 中加上 PowerLevel = 1 和 Rebirths = 0)。
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 } = {} -- 这个玩家当前一秒窗口开始的时间
local clickCount: { [Player]: number } = {} -- 这个窗口内已计入的点击

-- 把服务端的数字复制到玩家能看到的地方:leaderstats 和一个属性
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

-- 用传入的数据启动玩家(新的数字或保存的表)
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

-- 点击不带任何数字:它值多少由服务端计算
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 -- 连点器,或者在循环里调用远程事件的脚本
	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
	-- 重生用金币和升级换取永久倍率
	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

-- 初始数字:新的,或由 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) -- 正是 PlayerData 保存的那张表,所以每次修改都会被保存
	end
	PlayerData.Loaded:Connect(onLoaded)
	for _, player in Players:GetPlayers() do
		onLoaded(player) -- 在这个脚本启动前数据就已加载完的所有玩家
	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 以 Player 对象上的 PowerLevel 属性传给玩家,而不是 leaderstats 中的第三个值,所以玩家列表只显示 Coins 和 Rebirths。服务端设置的属性会复制到玩家的设备上;玩家在自己设备上做的修改只留在那里。

点击和频率限制

Click 远程事件不传递任何参数。在服务端,OnServerEvent 处理函数的第一个参数永远是调用它的玩家,所以服务端知道是谁点的,取出他的 Click Power 等级和 Rebirths,再把 clickValue 加到他的 Coins 上。请求里没有任何作弊者能改的东西。

Roblox 的安全指南说,永远不要只依赖客户端的频率限制,并把发放货币列为需要限制的操作之一。服务端按一秒的窗口统计每个玩家的点击:第一次点击开启窗口,计入 15 次点击后,其余的都会被忽略,直到从窗口开始过了一秒。在循环中调用远程事件的脚本,每个窗口最多也只能计入 15 次点击。想允许点得更快或更慢,修改 SimulatorConfig 中的 MAX_CLICKS_PER_SECOND。

升级和重生

BuyUpgrade 和 Rebirth 是 RemoteFunction,所以按钮可以等待回答并显示出来。每个处理函数都从服务端那份 SimulatorConfig 中取价格,检查玩家的 Coins,然后才做修改。它返回 true 或 false 以及一条消息,例如 "You need 5 more coins.",由 LocalScript 显示在状态栏中。

在检查价格和做修改之间,没有任何等待或让出执行(yield),所以同一个玩家的两个请求不可能在第一个扣走金币之前都通过检查。重生把 Coins 设为 0,Click Power 设为 1 级,并给 Rebirths 加 1,点击公式会把它变成 Rebirths + 1 的倍率。

SAVE_PROGRESS 开关

设为 SAVE_PROGRESS = false 时,每个玩家每次进入都从 0 枚金币开始,这正是你搭建游戏时需要的。第 4 步会打开它。那时脚本会等 PlayerData 模块加载好每个玩家,并直接操作这个模块保存的那张表,所以每枚金币和每次重生都会被保存,不需要额外的代码。

第 3 步:做出按钮

这个 LocalScript 用代码搭出整个界面:顶部的金币计数,中间的大 Click 按钮,底部的 Upgrade 和 Rebirth 按钮,以及显示服务端回答的状态栏。它自己从不修改任何数字。

  1. 在 Explorer 中展开 StarterPlayer,把鼠标悬停在 StarterPlayerScripts 上,插入一个名为 SimulatorClient 的 LocalScript。
  2. 用下面的代码替换它的内容,然后点击 Play。
LocalScript 位置: StarterPlayerScripts 名称: SimulatorClient
-- 创建模拟器的按钮并显示服务端的数字。它自己从不修改它们。

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

type Config = {
	MAX_POWER_LEVEL: number,
	clickValue: (powerLevel: number, rebirths: number) -> number,
	upgradeCost: (powerLevel: number) -> number,
	rebirthCost: (rebirths: number) -> number,
}
local Config = require(ReplicatedStorage:WaitForChild("SimulatorConfig")) :: Config
local remotes = ReplicatedStorage:WaitForChild("SimulatorRemotes")
local clickEvent = remotes:WaitForChild("Click") :: RemoteEvent
local buyUpgrade = remotes:WaitForChild("BuyUpgrade") :: RemoteFunction
local rebirthRemote = remotes:WaitForChild("Rebirth") :: RemoteFunction

local player = Players.LocalPlayer
local leaderstats = player:WaitForChild("leaderstats")
local coins = leaderstats:WaitForChild("Coins") :: IntValue
local rebirths = leaderstats:WaitForChild("Rebirths") :: IntValue

local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)

-- 1234 -> "1.2K", 5600000 -> "5.6M"
local UNITS = {
	{ size = 1e12, suffix = "T" },
	{ size = 1e9, suffix = "B" },
	{ size = 1e6, suffix = "M" },
	{ size = 1e3, suffix = "K" },
}
local function short(n: number): string
	for _, unit in UNITS do
		if n >= unit.size then
			return string.format("%.1f%s", math.floor(n / unit.size * 10) / 10, unit.suffix)
		end
	end
	return tostring(n)
end

local function newButton(parent: Instance, text: string, position: UDim2, size: UDim2, color: Color3): TextButton
	local button = Instance.new("TextButton")
	button.AnchorPoint = Vector2.new(0.5, 0.5)
	button.Position = position
	button.Size = size
	button.BackgroundColor3 = color
	button.TextColor3 = Color3.new(1, 1, 1)
	button.FontFace = BOLD
	button.TextScaled = true
	button.Text = text
	button.Parent = parent
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, 12)
	corner.Parent = button
	return button
end

local gui = Instance.new("ScreenGui")
gui.Name = "SimulatorGui"
gui.ResetOnSpawn = false

local coinsLabel = Instance.new("TextLabel")
coinsLabel.AnchorPoint = Vector2.new(0.5, 0)
coinsLabel.Position = UDim2.new(0.5, 0, 0, 12)
coinsLabel.Size = UDim2.fromOffset(320, 48)
coinsLabel.BackgroundTransparency = 1
coinsLabel.TextColor3 = Color3.fromRGB(255, 214, 90)
coinsLabel.FontFace = BOLD
coinsLabel.TextScaled = true
coinsLabel.Parent = gui

local clickButton = newButton(gui, "Click!", UDim2.new(0.5, 0, 0.5, -30), UDim2.fromScale(0.38, 0.38), Color3.fromRGB(124, 77, 255))
-- Click 按钮保持正方形,随屏幕大小缩放,但不超过 200 乘 200,
-- 这样在手机上它能放在金币计数和底部按钮之间
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"。这个数字只是用于显示的估计;
-- 一次点击实际值多少由服务端决定。
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)

按钮使用 Activated,Roblox 会在电脑上鼠标左键点击、手机上触碰,以及 UI 导航模式下按手柄的 A(或叉键)时触发它。

在手柄上,A 只会按下当前选中的按钮。开启 GuiService.AutoSelectGuiEnabled 时,手柄上的 Select 键会选中你的屏幕按钮;之后玩家可以在按钮之间切换并按 A。如果想让某个手柄按键直接点击,就用 ContextActionService 绑定它,并从中调用同一个 Click 远程事件。

脚本中的四个细节:

  • Click 按钮随屏幕缩放。它的大小是屏幕的一个比例,UIAspectRatioConstraint 让它保持正方形,UISizeConstraint 把它限制在 200 乘 200 像素以内。在显示器上它宽 200 像素;在手机上它会缩小,放在金币计数和底部按钮之间。如果移动元素,请让它离那些按钮远一点:Rebirth 没有确认步骤,误触可能会清空玩家的金币和升级。
  • 弹出的 "+N" 只是为了显示。它使用客户端那份公式。如果服务端因为频率限制忽略了这次点击,"+N" 仍会出现,但金币不会变化。
  • short() 让大数字易读。1,234 显示为 1.2K,5,600,000 显示为 5.6M。函数向下取整,所以计数永远不会显示比你实际拥有的更多。要显示比 T(万亿)更大的数字,就在 UNITS 中加条目。
  • 界面按事件更新。它监听 Coins 和 Rebirths 的值以及 PowerLevel 属性,所以无论数字怎么变,按钮上的价格都是对的。

ScreenGui 的 ResetOnSpawn 设为 false,所以角色复活时它会保留。这一点在这里很重要:StarterPlayerScripts 中的 LocalScript 只在玩家加入时复制一次,所以它不会重新搭建界面。

第 4 步:用 PlayerData 保存进度

目前玩家一离开,一切都会重置。模拟器不需要再写一个存档脚本,而是接入DataStore 教程中的 PlayerData 模块。这个模块已经会重试失败的请求,每 180 秒自动保存,在玩家离开和服务器关闭时保存,并且永远不会保存数据没有加载成功的玩家。

  1. 完成 DataStore 教程的第 1 步,把 ModuleScript PlayerData 加到 ServerScriptService 中。要在 Studio 中测试存档,请在游戏的测试副本中开启 Studio 对 API 服务的访问,如它的第一部分所述。SimulatorService 会自己通过 require 加载模块,所以这里不需要教程中的 Main 脚本。
  2. 在 PlayerData 的 DEFAULTS 表中,在 Coins = 0, 旁边加上 PowerLevel = 1, 和 Rebirths = 0,。
  3. 在同一个模块的 Data 类型中加上 PowerLevel: number, 和 Rebirths: number,,让严格类型检查知道新字段。
  4. 在 SimulatorService 中把 local SAVE_PROGRESS = false 改为 local SAVE_PROGRESS = true。

在你加字段之前就已保存过的玩家会自动获得这些字段:PlayerData 中的 migrate 函数会用 DEFAULTS 补齐保存的表中缺少的所有字段,所以他们会从 Click Power 1 级和 0 次重生开始,并保留自己的 Coins。如果跳过第 2 项,SimulatorService 会输出一条警告,列出需要添加的字段,并且不会启动这个玩家。

为什么模拟器直接写入 PlayerData 的表

开启存档后,SimulatorService 不会把数字复制到任何地方。PlayerData.Get(player) 返回模块保存的那张实时的表,模拟器就在这张表里修改 Coins、PowerLevel 和 Rebirths。每个数字只有一份,也只有一个脚本写入数据存储。两个保存同一个键的脚本会互相覆盖,其中一个可能把旧数字保存在另一个的数字之上。

不要像 DataStore 教程为其他游戏建议的那样,再在 Loaded 处理函数中创建 leaderstats:SimulatorService 已经从加载的表中创建了 Coins 和 Rebirths。如果排行榜脚本已经在创建 leaderstats,请删除它。

为什么不每次点击都保存

Roblox 允许每个服务器每分钟向普通数据存储写入 60 + 40 × 玩家数 次(其余限制见 DataStore 教程中的限制表)。在每秒 15 次点击时每次点击都保存,就是每个玩家每分钟 900 次写入,远超只有一个玩家的服务器所拥有的 100 次。每 180 秒、玩家离开时和服务器关闭时保存整张表,每个玩家只需几次写入,崩溃时最多丢失自上次自动保存以来的进度。

如果加载失败,模块会让玩家用新的数字游玩,但永远不会保存它们,所以一次失败的加载不会覆盖真实的进度。教程解释了模块如何处理这种情况。

为什么每个数字都由服务端决定

作弊者控制着自己的设备。Roblox 的安全指南说,他们可以修改自己本地游戏副本中的任何东西,并以任意参数、任意次数调用任何 RemoteEvent 或 RemoteFunction。模拟器的经济系统受到的保护,恰好与它的服务端脚本一样多。

作弊者可能尝试什么,以及 SimulatorService 怎么做
作弊者尝试如果由客户端决定SimulatorService 怎么做
在循环中尽可能快地调用 Click无限金币每个一秒窗口最多计入 15 次点击,其余忽略。
随点击一起发送金币数量他自己决定奖励忽略所有参数。点击的价值取自服务端的数字。
在金币不够时购买升级或重生免费升级用服务端的 Coins 核对价格,并回答 "You need N more coins."
在自己屏幕上修改 leaderstats 中的 Coins花掉他没有的金币从不读取 leaderstats。它只从自己的表写入那里。
在自己的 Player 上设置 PowerLevel 属性更强的点击从不读取这个属性,而修改只留在玩家的设备上。
同一时刻调用两次 Rebirth一次的价格两次重生每次调用都重新检查价格,而在检查和修改之间不会让出执行。
修改自己那份 SimulatorConfig 中的价格更便宜的升级使用它自己的那份模块。

这条规则适用于模拟器中的每个远程对象:发送玩家想做什么,而不是它值多少。RemoteEvent 教程更详细地讲解了如何校验远程对象的参数。

复制来的点击脚本中要避免什么

旧点击游戏教程中的常见做法,以及本教程的替代做法
做法问题本教程
LocalScript 通过 leaderstats.Coins.Value += 1 加金币修改只留在一台设备上,而作弊者控制着自己的设备由服务端加金币
clickEvent:FireServer(amount)客户端自己决定奖励Click 不传递参数
服务端没有频率限制Roblox 文档说永远不要只依赖客户端的限制每个一秒窗口最多 15 次点击
每次点击或升级都 SetAsync耗尽服务器的写入限额PlayerData 每 180 秒、离开时和关闭时保存。只在不能丢失的事情之后(例如用 Robux 购买)才用 PlayerData.SaveNow 立即保存。
只为模拟器另写一个数据存储脚本两个保存同一个键的脚本会互相覆盖写入 PlayerData 的表
用 while wait(1) do 循环做被动收入Roblox 把全局 wait 标为已弃用,由 task.wait 取代task.wait(见如何扩展)
按钮上用 MouseButton1Click它是为鼠标点击设计的Activated,适用于鼠标、触屏和手柄

第 5 步:测试

在 SimulatorService 中设为 SAVE_PROGRESS = false 时完成第 1 到第 8 项,让每次试玩测试都从新的数字开始。如果你已经在第 4 步开启了存档,先暂时设为 false,做第 9 项时再改回 true。

  1. 点击 Play。屏幕顶部显示 0 coins,绿色按钮上是 Upgrade: 10,橙色按钮上是 Rebirth: 1.0K。
  2. 按紫色的 Click! 按钮十次。每次点击都会显示金色的 +1,玩家列表中的 Coins 增加 1。
  3. 按 Upgrade。金币回到 0,状态栏变成绿色并显示 "Click Power is now level 2.",按钮上现在是 Upgrade: 15。从此每次点击得 2 枚金币。
  4. 不点击,直接按 Rebirth。状态栏显示 "You need 1000 more coins to rebirth.",什么都不变。
  5. 要不点 1,000 次就测试重生,先停止测试,在 SimulatorService 靠近末尾、启动新玩家的那一行中把 Coins = 0 改为 Coins = 1000,然后点 Play。按 Rebirth:Coins 变为 0,玩家列表中的 Rebirths 变为 1,状态栏显示 "Rebirth 1! Every click is now worth x2.",按钮上现在是 Rebirth: 3.0K。在 Click Power 1 级时,每次点击现在得 2 枚金币。之后把那一行改回 0。
  6. 要看到频率限制,把 SimulatorConfig 中的 MAX_CLICKS_PER_SECOND 设为 2 并快速点击。"+N" 会继续出现,但 Coins 每秒最多只增加 2 次点击的价值。改回 15。
  7. 在 Studio 的 Device Simulator 中选择一部手机(这是 Studio 的测试版功能;旧的 Device Emulator 也可以),然后点 Play。确认 Click 按钮既不压住金币计数,也不压住 Upgrade 和 Rebirth 按钮,并且按 Upgrade 时状态栏可见、没有被按钮遮挡。
  8. 在试玩测试中连接手柄,或打开 Studio 的 Controller Emulator(Emulation 选项卡中的 Controller),按 Select,确认三个按钮都能选到并用 A 按下。
  9. 开启存档(第 4 步)并重新设为 SAVE_PROGRESS = true 后,赚一些金币,点击 Stop,再点 Play。你的 Coins、Click Power 等级和 Rebirths 都会回来。

做一个健身房或挖矿模拟器

很多模拟器用世界中的动作代替按钮:举起哑铃、挥动镐子、在空中挥剑。底下还是同样的点击。Tool 可以调用同一个 Click 远程事件,所以 SimulatorService、它的价格和它的频率限制都保持不变。

  1. 在 Explorer 中把鼠标悬停在 StarterPack 上,插入一个 Tool,命名为 Dumbbell。在里面插入一个名为 Handle 的 Part,把它做成哑铃的形状,并取消勾选 Anchored,做法同剑教程中制作 Tool 的步骤。
  2. 在 Tool 中插入一个名为 LiftClient 的 LocalScript,粘贴下面的代码。
  3. 点击 Play,拿起哑铃并点击。每举一次,金币按你的 Click Power 增加,和按钮完全一样。
LocalScript 位置: StarterPack 中的 Tool Dumbbell 名称: LiftClient
-- Tool Dumbbell 中名为 LiftClient 的 LocalScript。
-- 每举一次就是一次点击:它调用与按钮相同的 Click 远程事件,由服务端
-- 决定它值多少,以及计入多少次举起。

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 -- 这台设备上两次举起之间的时间;服务端有自己的限制
local LIFT_ANIMATION_ID = "" -- 可选:"rbxassetid://" 加上你动画的 id

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

-- 每个角色只加载一次举起动画,通过 Roblox 放在 Humanoid 中的 Animator
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() -- 不带参数:奖励由服务端计算
end)

要加举起动画,在 Animation Editor 中把它做成 Action 优先级,发布后把它的 ID 粘贴到 LIFT_ANIMATION_ID 中。剑教程中的动画步骤同样适用。

  • 让服务端限制配合这个动作。LIFT_SECONDS 只会让诚实的玩家慢下来:作弊者可以从自己的代码调用 Click。如果举起是唯一的赚钱方式,就把 SimulatorConfig 中的 MAX_CLICKS_PER_SECOND 降到实际的节奏,例如每 0.5 秒举一次就设为 2,让脚本赚得不会比玩家多。然后重新计算节奏表:表中的每个时间都是按每秒 5 次点击计算的。
  • 保留或隐藏按钮。Click 按钮在 Tool 旁边仍然可用。要隐藏它,在 SimulatorClient 中创建 clickButton 的那一行之后加上 clickButton.Visible = false。
  • 只在特定地点赚钱。要只在健身房或矿洞里付钱,就在计入点击之前在服务端检查角色在哪里,例如检查它与该区域某个零件的距离。在 LiftClient 中检查拦不住任何人。

接下来做什么:模拟器的构建顺序

模拟器是叠在这个循环之上的一系列系统。按这个顺序搭建,让每个系统都有可以放大的东西,并在每个系统之后做一次试玩测试。下面是我们推荐的顺序,每一步都附有教程。

Roblox 模拟器的构建顺序,从核心循环向外扩展
顺序系统教程为什么是现在
1赚钱、升级、重生本教程其他一切都是在放大这个循环,所以先按节奏表调好它的数字。
2存档DataStore 教程,然后是第 4 步重新进入就清零的进度会毁掉模拟器。在玩家可能失去任何东西之前就加上它。
3作为倍率的蛋和宠物孵蛋和跟随玩家的宠物金币之外的第二个目标:可以收集、让每次点击更值钱的东西。
4靠重生解锁的区域如何扩展重生之后去哪里,奖励更好,并由服务端检查。
5排行榜排行榜教程按重生次数的全球前 10 名让漫长的成长有了意义。
6每日奖励和兑换码每日奖励和兑换码明天回来以及每次更新后回来的理由。
7游戏通行证游戏通行证教程2 倍金币、自动点击或额外的宠物栏位,在服务端检查。等免费循环已经好玩时再出售。

界面方面,免费的 Roblox UI 套件包含模拟器风格的界面,以及让它们运作的脚本。

不写脚本怎么做模拟器

模拟器总归需要脚本:总得有东西负责加金币、检查价格和保存。但不一定要你自己写:

  • Creator Store 中的模拟器套件。发布前读一读它的脚本,确认金币只在服务端 Script 中修改,而不是在 LocalScript 中。
  • 模拟器生成插件。对它创建的所有东西做同样的检查。
  • Studio 中的 AI 代理,例如 RoCode,它可以在你打开的场景中搭出同样这三个脚本。
  • Roblox 手机应用中的 Build。根据 Roblox 的文档,它能按描述制作较简单的 2D 和 2.5D 游戏,例如点击游戏,并按地区逐步推出。

无论你选哪种,都请对结果做一遍第 5 步的检查,以及为什么每个数字都由服务端决定一节中的防作弊检查。

如何扩展:宠物、区域、自动点击和排行榜

作为倍率的宠物

常见的做法是:每只宠物都是一个倍率。把玩家的宠物 id 列表保存在他的存档表中,由服务端把 clickValue 乘以每只已装备宠物的加成。在服务端开蛋:客户端请求开一个蛋,服务端检查并扣除价格,然后用加权随机抽取一只宠物。永远不要让客户端替蛋抽奖或说出抽到了哪只宠物。背包教程演示了如何存储、保存和显示玩家的物品,宠物也是同样的做法。孵蛋教程在服务端实现抽奖,宠物教程让宠物在主人身边飞。

靠重生解锁的区域

区域是地图上屏障后面、奖励更好的一部分。要锁住的是奖励,而不只是门:区域内一切会付钱的东西,在付钱之前都必须检查服务端表中玩家的 Rebirths。由 LocalScript 为符合条件的玩家打开的门可以用于显示,但作弊者可以在自己的设备上修改零件并移动自己的角色。

作为游戏通行证的自动点击

作为游戏通行证出售的自动点击器必须在服务端运行。把 Click 处理函数的主体移到一个函数中,例如 addClick(player),让远程事件连接它,再为通行证持有者从服务端循环中用 task.wait(0.5) 调用它,而不是用已弃用的 wait。这样自动点击会计入与普通点击相同的每秒限制。在服务端用 MarketplaceService:UserOwnsGamePassAsync 检查是否拥有,就像游戏通行证教程为自己的加成所做的那样。2 倍金币通行证也一样:在服务端为持有者把 clickValue 翻倍。定价之前,免费的 Robux 税费计算器会显示扣除 Roblox 分成后每笔销售给你带来多少,DevEx 计算器会显示这些 Robux 值多少美元。

按重生次数的全球前 10 名

leaderstats 只比较同一个服务器上的玩家。要给所有玩家的 Rebirths 排名,就把它们写入有序数据存储(ordered data store),再读回排在最前面的记录,做法同排行榜教程的第 4 步。有序存储允许的写入比普通存储少,每个服务器每分钟 30 + 5 × 玩家数 次,所以请在玩家离开时和按定时器写入。

非常大的数字

Luau 中的数字是 double,能保存大约 15 位有效数字。IntValue 能保存大约 922 京(9.2 quintillion)以内的整数,但 Roblox 警告,大于 2^53(约 9 千万亿)的值在脚本中会丢失精度。按这些设置,重生价格会在第 29 次重生时越过这个界限。如果你的游戏会走得更远,就把 leaderstats 的值改为 NumberValue(在两个脚本中替换 IntValue),它能以同样约 15 位的精度保存大得多的数字,并在 short() 中加上后缀。

模拟器游戏靠什么留住人

模拟器是数字的游戏。上面的点击、升级和重生就是整个循环;玩家会不会留下,取决于这些数字如何增长。每过几分钟,玩家都应该买得起某样能加快接下来几分钟的东西,每次游戏都应该在一个让人想回来的目标附近结束。

  • 能持续很久的增长。升级价格涨得比收入快,所以每一阶都要多花一点时间。重生清零金币换取永久倍率,旧区域变快了,成长又有了新鲜感。
  • 可以收集的东西。需要解锁的区域、从蛋里孵出并放大收入的宠物,以及可以升级的工具,让玩家在一个数字之外还有一串目标。
  • 保持易读的大数字。显示 1.5M 而不是 1500000,并以服务端即使在数字变大时也能比较的方式存储它们。

适合模拟器的变现方式

常见的通行证会翻倍金币、增加宠物栏位、一次开更多蛋或开启自动点击。把它们作为游戏通行证出售,并在服务端检查。金币包是 developer products。如果蛋或任何随机结果的东西可以用 Robux 或用 Robux 买来的货币购买,Roblox 要求在购买前显示概率:搭建商店之前请阅读 paid random items(英文)。

什么能让玩家回来

保存的进度、更新中的新区域或新一批宠物、每日奖励、随更新公布的兑换码,以及按重生次数的排行榜。其他游戏类型,各有自己的循环、系统和构建计划:Roblox 游戏类型。

常见错误与解决办法

在点击 Play 之前打开 Output 窗口(Window 菜单,然后 Output)。大多数问题都会在那里输出一条带脚本名和行号的警告或错误。

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

LocalScript 在等待 SimulatorService 启动时创建的远程对象。确认 SimulatorService 是 Script 而不是 LocalScript,它位于 ServerScriptService 中,并且 Output 中没有来自它的错误。如果 SimulatorConfig 出现同样的警告,说明模块不在 ReplicatedStorage 中,或名称不同。

按钮一直不出现

LocalScript 在搭建界面之前会等待你的 leaderstats。如果 Output 中在 leaderstats 上显示 Infinite yield possible,说明 SimulatorService 还没有启动你。设为 SAVE_PROGRESS = true 时它会等待 PlayerData,所以请确认 PlayerData 位于 ServerScriptService 中,并且加载时没有错误。

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

存档已开启,但 PlayerData 模块中还没有新字段。像第 4 步那样把它们加到它的 DEFAULTS 中,然后再点 Play。

"+1" 会弹出,但金币不增加

服务端没有计入点击。要么 SimulatorService 中有错误(在 Output 中找来自它的红字),要么点击来得比 MAX_CLICKS_PER_SECOND 允许的还快。如果玩家在正常游玩时就碰到限制,就在 SimulatorConfig 中调高它。

状态栏显示 "No answer from the server. Try again."

BuyUpgrade 或 Rebirth 的调用失败了,而不是返回了回答。常见原因是 SimulatorService 在处理请求时出错,所以请在 Output 中找来自它的红色错误:那里写明了行号。

屏幕上的金币计数和玩家列表显示的数字不同

另一个脚本也在创建 leaderstats 文件夹,所以每个玩家都有两个,LocalScript 可能读到了另一个。删除多余的脚本:SimulatorService 自己创建 Coins 和 Rebirths。

每次重新进入金币都清零

存档是关闭的。完成第 4 步。如果已经开启,但在 Studio 中金币仍然清零,请确认测试副本中开启了 Studio 对 API 服务的访问,如 DataStore 教程所述。

用 RoCode 来做

如果不想手动粘贴这些代码,RoCode 可以在你打开的场景中把它搭出来。它是独立的编程 AI 代理,不是 Roblox 出品:你在它的网页聊天里描述系统,它的 Roblox Studio 插件会在你的 Explorer 中创建脚本,所以你不需要从聊天窗口复制代码。

你输入

做一个点击模拟器:一个大的 Click 按钮,给出的金币等于我的 Click Power 等级乘以(重生次数 + 1),一个 Upgrade 按钮,价格 10 枚金币,每升一级贵 1.5 倍,以及一个 1,000 枚金币的 Rebirth 按钮,会清零金币和升级。数字放在服务端,并把点击限制在每秒 15 次。我已经有 PlayerData 模块了。

RoCode 的操作
  • 可以先用 Search Scripts 和 Read Script 读取你的 PlayerData 模块和任何 leaderstats 脚本,把字段加到你现有的数据中,而不是再写一个存档脚本
  • 可以用 Build UI 的 HUD 布局做出界面雏形(插件 3.9 及以上,模拟器风格),或在 LocalScript 中搭建按钮,并用 Create Script 编写 ModuleScript、服务端 Script 和 LocalScript
  • 它被要求用 Check Script 检查写好的每个脚本能否编译,Check Script 会在 Studio 中编译而不运行
  • 在每批改动前后设置撤销点,所以 Ctrl+Z 每次撤销一批

RoCode 不能创建游戏通行证和 developer products,也不能上传网格和宠物图标:这些要在 Creator Hub 和 Studio 中完成。使用插件 3.9.11 及以上时,RoCode 可以在 Studio 中对你的游戏进行试玩测试,并操控测试角色来确认一切正常;使用插件 3.9.15 及以上时,测试角色还能按屏幕按钮,例如按下 Click 并确认 Coins 增加了。它自己决定何时进行试玩测试,每次构建最多 2 次,外加 1 次用于检查自己的修复,而且只检查自己选择的内容,所以循环请你自己检查。完整的模拟器需要几条提示词,一次一个系统:如何用 RoCode 每条提示词搭一个系统。RoCode 如何连接 Studio。

常见问题

Roblox 不写脚本怎么做模拟器?

能玩的模拟器需要脚本:总得有东西负责加金币、检查价格和保存进度。你可以原样粘贴本教程的三个脚本,只修改 SimulatorConfig 中的数字,或者交给 Creator Store 的套件、插件或 AI 代理来做,并确认金币由服务端决定。可选方案。

重生系统是怎么运作的?

重生用你的金币和升级换取永久加成。在本教程中,第一次重生需要 1,000 枚金币;它把 Coins 设为 0,Click Power 设为 1 级,并给 Rebirths 加 1,之后每次点击都乘以 Rebirths + 1。每次重生的价格是上一次的三倍。

怎么做力量或健身房模拟器?

给玩家一个 Tool,例如哑铃,它的 LocalScript 在 Tool.Activated 时调用同一个 Click 远程事件。服务端计算奖励的方式和点击按钮完全一样。把服务端的点击限制降到举起的节奏,让脚本赚得不会比玩家多。脚本见哑铃版本一节。

模拟器需要哪些系统?

先是赚钱、升级和重生的循环,然后是存档,然后是放大收入的宠物或其他收集要素、靠重生解锁的区域、排行榜、每日奖励和兑换码,最后才是游戏通行证。构建顺序中每一项都有教程。

一次重生应该多久?

要足够长,让玩家先买几次升级,也要足够短,让他们在第一次游戏中就能重生一次。按本教程的数字,每秒点击 5 次时,第一次重生大约在 1.2 分钟后到来;如果把 REBIRTH_BASE_COST 提高到 10,000,大约是 8 分钟。更多设置见节奏表。

怎么防止连点器?

服务端在每个一秒窗口内每个玩家最多计入 15 次点击,其余忽略。在这个限制以下,脚本看起来和手快的玩家一样,所以保护经济系统的正是这个限制。你也可以把自动点击作为在服务端运行的游戏通行证出售。

为什么重新进入时金币会清零?

目前没有任何东西保存它们。加入 DataStore 教程中的 PlayerData 模块,在它的 DEFAULTS 中加上 PowerLevel 和 Rebirths,并在 SimulatorService 中设为 SAVE_PROGRESS = true,如第 4 步所述。

怎么给模拟器加宠物?

让每只宠物成为服务端应用到点击上的倍率。在服务端用加权随机开蛋,把玩家的宠物 id 和他的其他数据一起保存,并在背包 GUI 中显示它们,如背包教程所示。

点击零件好还是点击按钮好?

两种都行。屏幕按钮在手机上方便,带 ClickDetector 的零件适合一切都发生在世界里的游戏。根据 Roblox 的文档,服务端根本不检查 ClickDetector 事件,所以请用同样的方法在服务端限制这些点击的频率。

参考资料

代码如何验证:本页的所有脚本都已用 Roblox API 类型定义(luau-lsp,2026年11月20日)通过 Luau strict 类型检查。类型检查能发现 API 名称写错和类型不匹配,但发现不了游戏逻辑上的错误。发布前请务必在 Studio 中测试。

在你自己的游戏里试试 RoCode。

每天有免费额度,无需绑定银行卡。安装插件,描述你想要的功能,然后看看它在 Studio 里做了什么。