教程 · 游戏系统

Roblox Studio 怎么做按 Shift 奔跑,支持电脑、手机和主机

Roblox 里按 Shift 奔跑归根结底是一个数字:Humanoid 的 WalkSpeed,按住 Shift 时它会变大。第 1 步就用一个简短的 LocalScript 做到这一点,它同样支持手机上的 Sprint 按钮和手柄。教程的其余部分加入大型游戏需要的东西:体力条,基于新物理系统的冲刺,不会因为按住按键而误触发的二段跳,以及服务器能检查什么、不能检查什么。

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

要点

在 StarterPlayerScripts 中放一个 LocalScript,用 ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3) 绑定 Sprint 动作。按住 Shift 时给 Humanoid.WalkSpeed 加 10(16 变成 26),松开时恢复原来的值。参数 true 会在触摸屏上添加一个 Sprint 按钮,在本教程的脚本中,这个按钮和手柄上的 L3 是切换奔跑的开和关,而不是按住生效。

  • 在当前的 WalkSpeed 上加,而不是直接设为 26,这样游戏通行证给的加速才能保留。
  • 奔跑在玩家的设备上运行。服务器无法强制 WalkSpeed;它只能测量角色移动了多远,并标记奔跑无法解释的速度。
  • 第 2 到第 4 步基于同样的思路加入体力条、冲刺和二段跳。跑多快、跑多久,可以参考 按游戏类型的预设,里面有恐怖、战斗和开放世界的数值。
本页内容
  1. 工作原理
  2. 1. Shift 奔跑
  3. 2. 设置模块
  4. 3. 奔跑和冲刺
  5. 4. 二段跳
  6. 5. 服务端检查
  7. 6. 测试
  8. 速度预设
  9. 旧脚本
  10. Input Action System
  11. 扩展
  12. Common errors
  13. 使用 RoCode
  14. 常见问题
  15. 参考资料

Roblox 中的奔跑是怎么工作的

示意Shift 让角色以 WalkSpeed 26 奔跑,同时体力条减少;Q 消耗四分之一体力条冲刺;在空中第二次按跳跃会再跳一次。

每个玩家的设备移动他自己的角色。键盘、手柄或触摸屏决定角色往哪走,Roblox 再把结果传给服务器和其他所有人。所以奔跑就是一个在按住按键时提高 Humanoid.WalkSpeed 的 LocalScript,这也是第 1 步所做的全部。教程的其余部分是大型游戏围绕它所需的东西:体力条、冲刺、二段跳以及针对作弊者的服务端检查。

移动系统由哪些部分组成
部分位置作用
LocalScript ShiftToSprintStarterPlayerScripts单独使用的第 1 步:支持键盘、手机和手柄的奔跑,没有体力。加入体力和冲刺后,由 MovementClient 替代它。
ModuleScript MovementConfigReplicatedStorage数值:奔跑加成、体力和冲刺。LocalScript 和服务端检查都读取它们。
LocalScript MovementClientStarterPlayerScripts把 Sprint 和 Dash 绑定到按键、手柄按钮和触摸按钮,运行体力循环,绘制体力条并执行冲刺。
LocalScript DoubleJumpStarterCharacterScripts在空中多给一次跳跃。每个新角色中都会运行一个新的副本。
Script MovementCheckServerScriptService测量每个角色实际移动了多远,当有人长时间移动得比奔跑和冲刺允许的更快时,在 Output 中写一条警告。
移动系统完成后的 Explorer
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

如果 Script 和 LocalScript 的区别对你来说还很陌生,Script、LocalScript 和 ModuleScript 讲解了每种脚本在哪里运行以及为什么。

第 1 步:一个 LocalScript 实现按 Shift 奔跑

如果你只需要在按住 Shift 时跑得更快,这一个脚本就够了。它还会给手机屏幕上加一个 Sprint 按钮,在手柄上可以用左摇杆奔跑。

  1. 在 Explorer 中展开 StarterPlayer,把鼠标悬停在 StarterPlayerScripts 上,点击 + 按钮,插入一个名为 ShiftToSprint 的 LocalScript。
  2. 把它的内容替换为下面的代码,然后点击 Play。
LocalScript 位置: StarterPlayerScripts 名称: ShiftToSprint
-- StarterPlayer > StarterPlayerScripts 中名为 ShiftToSprint 的 LocalScript。
-- 按住 Left Shift 奔跑。在手柄上按下左摇杆(L3)
-- 开启或关闭奔跑。在手机上点击 Sprint 按钮开启或关闭奔跑。

local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")

-- 设置
local SPRINT_BONUS = 10 -- 奔跑时加到 WalkSpeed 上(16 变成 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false:需要按住按钮

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- 要恢复到的 WalkSpeed

local function getHumanoid(): Humanoid?
	local character = player.Character
	return character and character:FindFirstChildOfClass("Humanoid")
end

local function setSprinting(on: boolean)
	local humanoid = getHumanoid()
	if not humanoid or on == sprinting then
		return
	end
	sprinting = on
	if on then
		-- 记住当前速度并在其上增加,这样其他脚本给的加速会保留
		normalSpeed = humanoid.WalkSpeed
		humanoid.WalkSpeed = normalSpeed + SPRINT_BONUS
	else
		humanoid.WalkSpeed = normalSpeed
	end
end

local function onSprint(_name: string, state: Enum.UserInputState, input: InputObject): Enum.ContextActionResult
	local isKeyboard = input.UserInputType == Enum.UserInputType.Keyboard
	if isKeyboard or not TOGGLE_ON_TOUCH_AND_GAMEPAD then
		-- 按住:按键或按钮按下时奔跑
		if state == Enum.UserInputState.Begin then
			setSprinting(true)
		elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
			setSprinting(false)
		end
	elseif state == Enum.UserInputState.Begin then
		-- 切换:每次按下都开启或关闭奔跑
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- 一次调用就绑定按键、手柄按钮,以及触摸屏上的屏幕按钮
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- 新角色从步行开始:它的 Humanoid 已经是普通的 WalkSpeed
player.CharacterAdded:Connect(function()
	sprinting = false
end)

修改 SPRINT_BONUS 让奔跑更快或更慢。把 TOGGLE_ON_TOUCH_AND_GAMEPAD 设为 false,手机按钮和 L3 就会像 Shift 一样工作:只在按住时奔跑。

BindAction 把一个动作绑定到 Left Shift 和手柄的 L3 按钮,它的第三个参数 true 会在触摸屏上添加一个按钮;SetTitle 在按钮上写上 "Sprint"。处理函数还会收到输入本身,所以能区分键盘按键和手柄或触摸按钮。奔跑开始时,脚本记住当前的 WalkSpeed 并加上 SPRINT_BONUS;结束时恢复记住的值。由其他脚本设置的速度,例如 游戏通行证教程里的 Speed 福利,会被保留。新角色从普通的 WalkSpeed 开始,所以 CharacterAdded 处理函数只重置标志。

按住还是切换?

当 TOGGLE_ON_TOUCH_AND_GAMEPAD 为 true 时,ShiftToSprint 在各设备上的工作方式
设备和输入工作方式原因
键盘:Left Shift按住移动时按住按键很容易,松开就立即停止奔跑。
手柄:按下左摇杆(L3)切换一边按住摇杆一边用它控制方向很累。
手机或平板:屏幕上的 Sprint 按钮切换按住按钮的拇指没法同时去按 Jump。

要测试,点击 Play,走路时按住 Shift:速度从每秒 16 stud 升到 26,松开就会慢下来。对于手机,在 Studio 的 Device Simulator 中选择一部手机,点击 Play,点一次 Sprint 开始,再点一次停止。对于手柄,在试玩测试时打开 Controller Emulator 并按 L3。各设备的完整检查清单在 第 6 步。

第 2 步和第 3 步用另一个带体力条和冲刺的脚本替换这个脚本。第 4 步和第 5 步加入二段跳和服务端检查,两个脚本中的任何一个都能配合使用。

第 2 步:体力和冲刺的数值放在一个模块里

为了做出会耗尽的奔跑,第 2 步和第 3 步把 ShiftToSprint 换成一个更大的 LocalScript,带有体力条和冲刺。先删除 ShiftToSprint:两个脚本都会绑定 Sprint 动作。

所有数值都放在一个 ModuleScript 里,所以移动手感只在一个地方调整。MovementClient 在每个玩家的设备上读取它们,MovementCheck 在服务器上读取同一个模块,以知道奔跑和冲刺的速度应该是多少。

  1. 在 Explorer 中把鼠标悬停在 ReplicatedStorage 上,点击 + 按钮,插入一个 ModuleScript。
  2. 把它重命名为 MovementConfig,并把内容替换为下面的代码。
ModuleScript 位置: ReplicatedStorage 名称: MovementConfig
-- 供移动 LocalScript 和服务端速度检查共用的一组数值。

local MovementConfig = {
	SPRINT_BONUS = 10, -- 加到当前 WalkSpeed 上:16(Roblox 默认值)变成 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 满体力条可以奔跑 5 秒
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- 奔跑结束后,体力开始恢复前的秒数
	MIN_TO_START = 20, -- 开始奔跑所需的体力,避免空体力条闪烁

	DASH_SPEED = 60, -- 冲刺时每秒的 stud 数
	DASH_SECONDS = 0.2, -- 这样冲刺大约移动 12 stud
	DASH_COST = 25, -- 体力
	DASH_COOLDOWN = 1,
}

return MovementConfig
每个设置的作用
设置值效果
SPRINT_BONUS10奔跑时加到 WalkSpeed 上。Roblox 的 WalkSpeed 默认是 16,所以奔跑速度是每秒 26 stud。
MAX_STAMINA100满体力条。
DRAIN_PER_SECOND20满体力条够奔跑 5 秒。
REGEN_PER_SECOND15空体力条大约 6.7 秒回满。
REGEN_DELAY1开始恢复前休息的秒数。
MIN_TO_START20开始奔跑所需的体力。
DASH_SPEED60冲刺时每秒的 stud 数。
DASH_SECONDS0.2冲刺持续的时间:以每秒 60 stud 计算大约 12 stud。
DASH_COST25每次冲刺消耗的体力。
DASH_COOLDOWN1两次冲刺之间的秒数。

每一端都运行自己的模块副本(模块在每一端各运行一次),所以在自己设备上修改这些数值的玩家只改了他自己的副本。但这在这里保护不了什么:他的设备本来就在移动他的角色,所以不管模块里写什么,它都可以给自己无限体力。第 5 步的服务端检查正是考虑到这一点设计的。

第 3 步:带体力的奔跑和冲刺

这个 LocalScript 做的是玩家能感受到的部分。它绑定 Sprint 和 Dash,绘制体力条,每帧运行体力循环并执行冲刺。

  1. 在 Explorer 中展开 StarterPlayer,把鼠标悬停在 StarterPlayerScripts 上,插入一个名为 MovementClient 的 LocalScript。
  2. 把它的内容替换为下面的代码。
LocalScript 位置: StarterPlayerScripts 名称: MovementClient
-- 按住 Shift(或 L3,或手机上的 Sprint 按钮),在有体力时奔跑。
-- 按 Q(或 B,或 Dash 按钮)朝移动方向冲刺。

local ContextActionService = game:GetService("ContextActionService")
local Debris = game:GetService("Debris")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

type Config = {
	SPRINT_BONUS: number,
	MAX_STAMINA: number,
	DRAIN_PER_SECOND: number,
	REGEN_PER_SECOND: number,
	REGEN_DELAY: number,
	MIN_TO_START: number,
	DASH_SPEED: number,
	DASH_SECONDS: number,
	DASH_COST: number,
	DASH_COOLDOWN: number,
}
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config

local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- 奔跑结束时要恢复到的 WalkSpeed
local lastSprintTime = 0
local lastDashTime = -math.huge

-- 体力条:一个外框加一个填充,填充的宽度等于剩余体力
local gui = Instance.new("ScreenGui")
gui.Name = "StaminaGui"
gui.ResetOnSpawn = false
local bar = Instance.new("Frame")
bar.AnchorPoint = Vector2.new(0.5, 1)
bar.Position = UDim2.new(0.5, 0, 1, -24)
bar.Size = UDim2.fromOffset(240, 14)
bar.BackgroundColor3 = Color3.fromRGB(30, 26, 40)
bar.Parent = gui
local fill = Instance.new("Frame")
fill.Size = UDim2.fromScale(1, 1)
fill.BackgroundColor3 = Color3.fromRGB(80, 220, 150)
fill.BorderSizePixel = 0
fill.Parent = bar
for _, frame in { bar, fill } do
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(1, 0)
	corner.Parent = frame
end
gui.Parent = player:WaitForChild("PlayerGui")

local function getHumanoid(): Humanoid?
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid and humanoid.Health > 0 then
		return humanoid
	end
	return nil
end

-- 奔跑:这里只设置标志;下面的 Heartbeat 循环每帧决定是否奔跑
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- 只有按下和松开会改变它:在触摸按钮上滑动的手指会发送 Change
	if state == Enum.UserInputState.Begin then
		sprintHeld = true
	elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
		sprintHeld = false
	end
	return Enum.ContextActionResult.Pass
end

local function dash()
	local humanoid = getHumanoid()
	local rootPart = humanoid and humanoid.RootPart
	local now = os.clock()
	-- 坐着时不能冲刺:坐着的角色焊接在座位上,会推动整辆载具
	if not (humanoid and rootPart) or humanoid.Sit or now - lastDashTime < Config.DASH_COOLDOWN or stamina < Config.DASH_COST then
		return
	end
	local attachment = rootPart:FindFirstChild("RootAttachment")
	if not (attachment and attachment:IsA("Attachment")) then
		return
	end
	lastDashTime = now
	stamina -= Config.DASH_COST
	lastSprintTime = now -- 像奔跑一样暂停恢复

	-- 朝玩家移动的方向冲刺,站着不动时朝他面对的方向
	local direction = humanoid.MoveDirection
	if direction.Magnitude < 0.1 then
		direction = rootPart.CFrame.LookVector
	end
	direction = Vector3.new(direction.X, 0, direction.Z).Unit

	-- Plane 模式的 LinearVelocity 保持水平速度,不干扰重力
	local velocity = Instance.new("LinearVelocity")
	velocity.Attachment0 = attachment
	velocity.RelativeTo = Enum.ActuatorRelativeTo.World
	velocity.VelocityConstraintMode = Enum.VelocityConstraintMode.Plane
	velocity.PrimaryTangentAxis = Vector3.xAxis
	velocity.SecondaryTangentAxis = Vector3.zAxis
	velocity.PlaneVelocity = Vector2.new(direction.X, direction.Z) * Config.DASH_SPEED
	velocity.MaxForce = math.huge
	velocity.Parent = rootPart
	Debris:AddItem(velocity, Config.DASH_SECONDS)
end

local function onDash(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	if state == Enum.UserInputState.Begin then
		dash()
	end
	return Enum.ContextActionResult.Pass
end

-- 每次调用都绑定按键、手柄按钮,以及触摸设备上的屏幕按钮
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:BindAction("Dash", onDash, true, Enum.KeyCode.Q, Enum.KeyCode.ButtonB)
ContextActionService:SetTitle("Sprint", "Sprint")
ContextActionService:SetTitle("Dash", "Dash")

-- 每帧:奔跑并移动时消耗体力,短暂休息后恢复
RunService.Heartbeat:Connect(function(deltaTime: number)
	local humanoid = getHumanoid()
	if not humanoid then
		return
	end
	local moving = humanoid.MoveDirection.Magnitude > 0
	local now = os.clock()
	local enoughStamina = if sprinting then stamina > 0 else stamina >= Config.MIN_TO_START
	local shouldSprint = sprintHeld and moving and enoughStamina

	-- 只在奔跑开始和结束时修改 WalkSpeed,这样由
	-- 其他脚本(例如速度通行证)设置的速度会保留,奔跑在其上增加
	if shouldSprint and not sprinting then
		sprinting = true
		normalSpeed = humanoid.WalkSpeed
		humanoid.WalkSpeed = normalSpeed + Config.SPRINT_BONUS
	elseif not shouldSprint and sprinting then
		sprinting = false
		humanoid.WalkSpeed = normalSpeed
	end

	if sprinting then
		stamina = math.max(0, stamina - Config.DRAIN_PER_SECOND * deltaTime)
		lastSprintTime = now
	elseif now - lastSprintTime >= Config.REGEN_DELAY then
		stamina = math.min(Config.MAX_STAMINA, stamina + Config.REGEN_PER_SECOND * deltaTime)
	end
	fill.Size = UDim2.fromScale(stamina / Config.MAX_STAMINA, 1)
end)

-- 新角色从满体力开始,什么都没按住
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- 新的 Humanoid 从普通的 WalkSpeed 开始
end)

体力条在代码中创建,ResetOnSpawn 为 false,所以重生后它仍留在屏幕上,而底部的 CharacterAdded 处理函数会为每个新角色重新填满它。type Config 这几行描述了模块返回的内容,让严格类型检查能发现设置名的拼写错误;它们在游戏运行时不改变任何东西。

一次调用搞定键盘、手柄和手机按钮

ContextActionService:BindAction 接收动作名、处理函数、是否创建触摸按钮,然后是各个输入。第三个参数传 true 时,ContextActionService 会在触摸设备的屏幕上添加一个按钮,放在玩家 PlayerGui 中名为 ContextActionGui 的 ScreenGui 里。SetTitle 在这些按钮上写上 "Sprint" 和 "Dash"。BindAction 最多只能创建 7 个触摸按钮,所以如果游戏里其他脚本也在用,请注意数量。

处理函数会收到输入状态:按下时是 Begin,松开时是 End。onSprint 只记录 Sprint 是否被按住。它把 Cancel 也当作松开,这是另一个绑定接管输入时 ContextActionService 发出的状态;它忽略 Change,这是手指在触摸按钮上移动时可能发出的。两个处理函数都返回 Pass,所以同一按键上的下一个绑定也能收到输入。

Roblox 关于 ContextActionService 的参考文档建议在大多数情况下用它代替 UserInputService.InputBegan。它的例子是:按 H 按汽车喇叭,玩家在聊天打字时不应该响。绑定只有在它是该输入的最后一个绑定时才会触发,所以当聊天占用键盘时,你什么都不用检查。手柄输入是 ButtonL3(按下左摇杆,移动时按住)和 ButtonB。Roblox 自己的奔跑示例用的是 ButtonY,所以如果你的游戏这样更顺手,改一下 BindAction 中的 KeyCode 即可。

体力循环

RunService.Heartbeat 在每帧物理步进之后触发,并传入 deltaTime,即距离上一帧的秒数。用它乘以消耗和恢复的速度,无论游戏以每秒 30 帧还是 240 帧运行,满体力条都够跑 5 秒。

每一帧,循环都会决定角色是否应该奔跑:Sprint 被按住,角色正在走(站着不动时 Humanoid.MoveDirection 是零向量),并且还有体力。开始奔跑至少需要 MIN_TO_START(20);继续奔跑只要大于 0 就行。没有这个差距的话,一个每帧回一点的空体力条会让奔跑每帧开关一次。恢复在最后一次奔跑或冲刺后 REGEN_DELAY(1 秒)开始,所以体力耗尽后,玩家大约要等 2.3 秒才能再次奔跑。

WalkSpeed 只在奔跑开始或结束的那一帧改变。开始时,脚本记住当前的 WalkSpeed 并加上 SPRINT_BONUS;结束时恢复记住的值。所以其他脚本设置的速度会被保留:游戏通行证教程里的 Speed 福利 把 WalkSpeed 设为 24,配合这个脚本,拥有者会以 34 奔跑。每帧或每次松开都写 WalkSpeed = 16 的脚本,会悄悄抵消这个福利。

冲刺

冲刺把角色推向他移动的方向,站着不动时推向他面对的方向,而且方向会被压平,永远不会朝上或朝下。它消耗 25 体力,像奔跑一样暂停恢复,冷却时间 1 秒。它不检查地面,所以在空中也能用,和二段跳很搭。角色坐着时冲刺什么都不做:坐着的角色焊接在座位上,在载具里推力可能会推动整辆载具。

推力是根零件 RootAttachment 上的 LinearVelocity 约束。在带 X 和 Z 轴的 Plane 模式下,它保持每秒 60 stud 的水平速度,不碰垂直方向,所以重力照常作用,从边缘冲出去会正常下落。MaxForce 是 math.huge,所以推力不受限制。Debris:AddItem 在 DASH_SECONDS 后销毁约束,而不让脚本等待,所以冲刺持续 0.2 秒,以这个速度大约 12 stud。

旧教程使用 BodyVelocity,Roblox 已把它标为已弃用,并注明改用 LinearVelocity。它在某个轴上把 MaxForce 设为零的技巧,被 LinearVelocity 的 Line、Plane 和 Vector 模式所取代。由于玩家的设备自己模拟自己的角色,LocalScript 创建的约束就能移动它,其他玩家看到的冲刺和其他任何移动一样。

Roblox 自己的 UI 教程也是这样把约束挂到 humanoid.RootPart.RootAttachment 上的。如果你的游戏使用自定义角色,而它的根零件上没有名为 RootAttachment 的 Attachment,冲刺就什么都不做:把它加到你的 StarterCharacter 的 HumanoidRootPart 里。

第 4 步:二段跳

二段跳放在 StarterCharacterScripts 中自己的 LocalScript 里。Roblox 在每个角色生成时把这个容器里的脚本复制一份放进角色,这些副本不会跨越重生保留,所以每条命都从一个新脚本开始,不会从上一条命带过来任何东西。

  1. 在 Explorer 中展开 StarterPlayer,把鼠标悬停在 StarterCharacterScripts 上,插入一个名为 DoubleJump 的 LocalScript。
  2. 把它的内容替换为下面的代码。
LocalScript 位置: StarterCharacterScripts 名称: DoubleJump
-- 在空中多给一次跳跃。每个新角色都会重新运行,
-- 所以重生后不会带过来任何东西。

local UserInputService = game:GetService("UserInputService")

local character = script.Parent :: Model
local humanoid = character:WaitForChild("Humanoid") :: Humanoid

local EXTRA_JUMPS = 1
local MIN_SECONDS_BETWEEN_JUMPS = 0.25 -- 一次按下 JumpRequest 会触发好几次
local NEW_PRESS_GAP = 0.1 -- 按住的跳跃按钮会持续发送 JumpRequest;这么长的间隔表示已经松开

local jumpsLeft = 0
local lastJump = 0
local lastRequest = 0

humanoid.StateChanged:Connect(function(oldState: Enum.HumanoidStateType, newState: Enum.HumanoidStateType)
	if newState == Enum.HumanoidStateType.Jumping and oldState ~= Enum.HumanoidStateType.Freefall then
		-- 从地面起跳(而不是我们的空中跳跃)会恢复空中跳跃次数
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- 玩家请求跳跃时 JumpRequest 触发,例如按 Space 或手机上的跳跃按钮
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- 只有新的按下才能再跳,这样按住的按钮不会浪费空中跳跃
	if not newPress or jumpsLeft <= 0 or now - lastJump < MIN_SECONDS_BETWEEN_JUMPS then
		return
	end
	if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
		jumpsLeft -= 1
		lastJump = now
		humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
	end
end)

把 EXTRA_JUMPS 设为 2 就是三段跳。

脚本通过 Humanoid.StateChanged 观察角色的状态。不是从 Freefall 进入 Jumping 的转换,就是从地面起跳,所以它会给一次空中跳跃,而 Landed 又会把它收回。如果从边缘走下去,角色不经过跳跃就进入 Freefall,所以得不到空中跳跃。如果这种情况也需要,在从 Jumping 以外的任何状态进入 Freefall 时也设置 jumpsLeft。

玩家请求跳跃时 UserInputService.JumpRequest 会触发,例如按 Space 或手机上的跳跃按钮。Roblox 的参考文档提醒,一次跳跃请求它会触发好几次,并建议做防抖,所以脚本会忽略上次跳跃后 0.25 秒内的请求。按住的跳跃按钮也可能持续请求跳跃,并在角色离地的一瞬间就用掉空中跳跃,所以只有在 0.1 秒没有请求之后,请求才算作新的按下。

空中跳跃本身就是 Humanoid:ChangeState(Enum.HumanoidStateType.Jumping)。Roblox 的参考文档说,它需要从拥有角色网络所有权的设备上的 LocalScript 调用,默认就是玩家自己的设备,而不是服务器。参考文档里 ChangeState 的示例代码恰好就是二段跳。

第 5 步:在服务器上抓加速作弊

奔跑教程常常停在客户端。服务端 Script 不能信任玩家的 WalkSpeed,因为作弊者会在自己的设备上修改它,但服务器能看到他们的角色最终在哪里。MovementCheck 每秒测量两次,当有人长时间移动得比奔跑和冲刺允许的更快时,在 Output 中写一条警告。它从 MovementConfig 读取奔跑和冲刺的数值,所以即使你保留了 ShiftToSprint,也要加上 第 2 步 的这个模块。

  1. 把鼠标悬停在 ServerScriptService 上,插入一个名为 MovementCheck 的 Script。
  2. 把它的内容替换为下面的代码。
Script 位置: ServerScriptService 名称: MovementCheck
-- 玩家的设备移动自己的角色,所以作弊者可以设置任意 WalkSpeed。
-- 这项检查测量每个角色实际移动了多远,并在有人长时间
-- 移动得比奔跑和冲刺允许的更快时写入 Output。它只发出警告:
-- 延迟、传送和传送带都可能看起来像超速,所以在惩罚任何人之前先调好它。

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

type Config = { SPRINT_BONUS: number, DASH_SPEED: number, DASH_SECONDS: number }
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config

local CHECK_EVERY = 0.5 -- 秒
-- 奔跑速度加上应对延迟的余量。如果你出售加速,请调大。
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- 留给一两次冲刺的余量
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- 之前的冲刺被原谅的速度

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- 测量 lastPosition 时用的根零件
local excess: { [Player]: number } = {} -- 超出允许范围的 stud 数,会逐渐被原谅

Players.PlayerRemoving:Connect(function(player: Player)
	lastPosition[player] = nil
	lastRoot[player] = nil
	excess[player] = nil
end)

while true do
	task.wait(CHECK_EVERY)
	for _, player in Players:GetPlayers() do
		local character = player.Character
		local rootPart = character and character:FindFirstChild("HumanoidRootPart")
		if rootPart and rootPart:IsA("BasePart") then
			local position = rootPart.Position
			-- 重生会产生新的根零件,而服务端传送(回合开始、存档点)
			-- 会设置下面的属性:重新开始测量,而不是标记这次跳变
			local previous = if lastRoot[player] == rootPart then lastPosition[player] else nil
			if player:GetAttribute("MovementCheckSkip") then
				player:SetAttribute("MovementCheckSkip", nil)
				previous = nil
			end
			lastPosition[player] = position
			lastRoot[player] = rootPart
			if previous then
				-- 只算水平移动:下落得快不算作弊
				local moved = Vector3.new(position.X - previous.X, 0, position.Z - previous.Z).Magnitude
				local extra = moved - SPEED_ALLOWANCE * CHECK_EVERY
				local total = math.max(0, (excess[player] or 0) + extra - DRAIN_PER_CHECK)
				excess[player] = total
				if total > BURST_ALLOWANCE then
					warn(`MovementCheck: {player.Name} moved {math.round(moved / CHECK_EVERY)} studs/s`)
					excess[player] = 0
				end
			end
		else
			lastPosition[player] = nil
			lastRoot[player] = nil
		end
	end
end

警告出现在 Studio 的 Output 中。在正式游戏中,它会进入 Developer Console 的服务器日志,作为游戏所有者你可以查看:见 正式游戏中的输出。

它测量什么

每隔半秒,脚本读取每个角色根零件的位置,并测量它自上次检查以来在水平方向移动了多少。高度被忽略,所以下落和跳跃永远不会被计入;Roblox 关于移动验证的建议,对在地面上行走的游戏也是同样投影到 XZ 平面。允许值是默认步行速度加上奔跑加成,再加四分之一应对延迟:每秒 32.5 stud。超出的距离会进入一个“漏桶”,这是一种累加器,Roblox 文档说它很适合许多开发者用来处理短时间的爆发。桶每次检查漏掉 3 stud,当桶里超过 24 stud 时脚本发出警告,这大约是两次冲刺的余量。

按它的数值计算,这项检查能抓到什么
作弊者MovementCheck 的反应
把 WalkSpeed 设为 100奔跑大约 1 秒后发出警告
把 WalkSpeed 设为 50奔跑大约 2.5 秒后发出警告
没有冷却地连续冲刺(每秒 60 stud)大约 1.5 秒后发出警告
一次传送超过 43 stud下一次检查时发出警告
以最高每秒 38 stud 的速度奔跑,大约是奔跑速度的一倍半没有反应:低于每秒 38.5 stud 时,桶漏得和装得一样快
修改自己的 MovementConfig 来获得无限体力没有反应:以每秒 26 stud 奔跑多久都是允许的
飞行、无限跳跃或穿墙没有反应:检查忽略高度,也不看碰撞

也就是说,这项检查能抓到让玩家明显比其他人快的粗暴作弊,而放过小心的作弊。这是基于距离的检查的真实上限,也是 Roblox 在做更强方案的原因(见下面的 server authority)。

为什么它只发警告

Roblox 文档指出,简单的速度检查可能会标记网络不稳定的正常玩家,在有载具或其他复杂移动的游戏中也会失效。延迟跳变、传送带、载具、把角色炸飞的爆炸,以及你自己的传送,都可能看起来像超速,所以脚本只打印警告。在你和测试者正常游玩时观察 Output,如果正常玩家触发了它就调大 SPEED_ALLOWANCE,只有当检查在正常游戏中保持安静时,才加入惩罚,例如把玩家拉回去。如果你的游戏里爆炸会把角色炸飞,还要跳过 Humanoid 已经没有血量的玩家。

重生和传送

重生会创建新的根零件,脚本看到它时会重新开始测量,所以死在远离出生点的地方永远不会被算作超速。你自己的服务端脚本做的传送需要例外处理,正如 Roblox 文档对所有带传送的游戏所说的那样。传送之后加上 player:SetAttribute("MovementCheckSkip", true),下一次检查就会从新位置开始测量,而不是标记这次跳变:

  • 在 回合系统 中,紧跟在 startRound 里的 character:PivotTo(...) 之后。
  • 在 跑酷存档点脚本 中,紧跟在每个把玩家送到其存档点的 character:PivotTo(...) 之后。

传送教程 里的传送垫和菜单,以及 第一个游戏教程 里的 Finish 垫,已经在每次移动后设置了它。

只有服务器上的值才算数。玩家在自己设备上设置的属性只留在那台设备上(见 什么会复制,什么不会),所以作弊者无法用它关闭检查。

面向未来的方案:server authority

Roblox 的安全文档把 server authority 模型(撰写本文时处于测试阶段)称为阻止移动类作弊最可靠的方式。服务器成为唯一可信的来源,玩家的设备只报告自己的输入,文档说这能让加速作弊失效,因为设备从来不被信任去报告自己的位置。

迁移是重写,而不是调整。在这个模型中,移动由服务器计算,所以只由 LocalScript 设置的 WalkSpeed 或 LinearVelocity 会在服务器状态到达时被撤销。Roblox 文档说,核心逻辑应当在客户端和服务器都运行的 ModuleScript 中的 RunService:BindToSimulation() 函数里运行。这个模型还需要几项 Workspace 设置,包括 PlayerScriptsUseInputActionSystem,所以你的操控也要迁移到 Input Action System。在把奔跑、体力和冲刺迁移到这个方案之前,先保留本教程的版本。在那之前,像这样基于距离的检查,正是 Roblox 关于移动验证的部分所描述的做法。

第 6 步:在每种设备上测试

  1. 点击 Play,走路时按住 Shift。速度从每秒 16 stud 升到 26,屏幕底部的绿色体力条变短。大约 5 秒后它就空了,你又恢复步行。
  2. 松开 Shift。1 秒后体力条开始回满。在它回到五分之一之前,按 Shift 没有任何作用。
  3. 走路时按 Q:你会往前冲一小段,体力条少了四分之一。马上再按一次 Q,在一秒过去之前什么都不会发生。如果冲刺感觉太短或太长,修改 MovementConfig 中的 DASH_SPEED 或 DASH_SECONDS。
  4. 跳起来,然后在空中再按一次跳跃完成二段跳。落地后再试一次:每次从地面起跳都会恢复空中跳跃。
  5. 整个跳跃过程中一直按住 Space。应该只跳一次而不是两次,因为空中跳跃需要一次新的按下。
  6. 开启 Studio 的 Device Simulator(撰写本文时它是测试功能:File、Beta Features、New Device Simulator,然后重启 Studio),或者在 Test 菜单中开启旧的 Device Emulator。选择一部手机并点击 Play。会出现 Sprint 和 Dash 按钮。一边控制方向一边按住 Sprint,然后在整个跳跃过程中按住跳跃按钮,确认只跳了一次。
  7. 打开 Controller Emulator(Emulation 标签页上的 Controller,或 Device Simulator 面板上的 Virtual controller)。移动时按住 L3 奔跑,按 B 冲刺,按两次 A 二段跳。
  8. 通过游戏菜单重置角色。体力条又满了,Output 里没有 MovementCheck 警告,如果你还在模拟手机,Sprint 和 Dash 按钮也都还在。
  9. 现在扮演作弊者。点击 Client/Server 切换按钮,直到 Explorer 显示客户端,在 Workspace 中选中你角色的 Humanoid,在 Properties 窗口中把 WalkSpeed 设为 60。走几秒钟:Output 里会出现类似 MovementCheck: YourName moved 60 studs/s 的警告。改回 16,然后像平常一样奔跑和冲刺一分钟,确认 Output 保持安静。
  10. 如果你的场景中 Workspace.PlayerScriptsUseInputActionSystem 设为 Enabled,请再测试一次二段跳:Roblox 文档没有说明在这种情况下 JumpRequest 的行为是否相同。

如果什么都没有发生,通过 Studio 的 Window 菜单打开 Output 窗口,找一找来自 MovementClient 的红色错误,或者看看 常见错误。

跑多快、跑多久:按游戏类型的预设

合适的奔跑取决于游戏。恐怖游戏的追逐需要短而慢、在最糟糕的时刻耗尽的奔跑;大型开放地图需要长时间的奔跑,让玩家穿越地图时不觉得无聊。这些预设使用同样的脚本,只修改步行速度和 MovementConfig。它们是我们根据设置计算出的起点,而不是在玩家身上测出来的。

按游戏类型的步行速度、奔跑和体力。奔跑时间是 MAX_STAMINA / DRAIN_PER_SECOND;恢复时间是 MAX_STAMINA / REGEN_PER_SECOND 加上 1 秒的 REGEN_DELAY
游戏类型CharacterWalkSpeedSPRINT_BONUS(奔跑速度)DRAIN_PER_SECONDREGEN_PER_SECOND满体力奔跑从空到满一条体力的距离
本教程1610 (26)20155 秒7.7 秒130 stud
恐怖游戏追逐128 (20)25104 秒11 秒80 stud
战场和战斗1612 (28)15206.7 秒6 秒约 187 stud
开放世界或模拟器1616 (32)102510 秒5 秒320 stud
Obby 或跑酷168 (24)不用体力:使用 ShiftToSprint
  • 步行速度在 StarterPlayer 中设置。选中 StarterPlayer,设置 CharacterWalkSpeed(默认 16)。每个新角色都从这个速度开始,奔跑在它的基础上加 SPRINT_BONUS,MovementCheck 也读取它,所以服务端检查会跟着你的选择走。
  • MovementCheck 会自动适应。它允许步行速度加奔跑加成,再加四分之一应对延迟:恐怖预设是每秒 25 stud,开放世界是 40。别的都不用改。
  • 在跑酷里,奔跑会改变赛道。奔跑越快,能跳过的间隙越长。搭好跳跃后,用奔跑速度逐个测试,否则奔跑会让关卡太简单。跑酷存档点教程 和 ShiftToSprint 很搭。
  • 在恐怖游戏里,参照物是杀手。让追逐者比步行速度快一点、比奔跑慢一点,这样能否逃脱就取决于体力条什么时候耗尽。恐怖游戏教程 讲解了循环的其余部分。

旧的奔跑脚本有什么问题

关于奔跑、冲刺和二段跳的旧教程很多仍然能用,但不少使用了 Roblox 后来已经替换的做法,或者会破坏你游戏里的其他系统。如果你在修一个复制来的脚本,对照这份清单检查一下。

旧教程中的做法,以及本教程的替代方案
做法问题在哪本教程
用 BodyVelocity 冲刺已弃用:Roblox 说要改用 LinearVelocityPlane 模式的 LinearVelocity
基于 RunService.RenderStepped 的循环对新的工作,它已被 PreRender 取代。体力这类游戏逻辑应该放在 Heartbeat 上,Roblox 把它描述为用于周期性任务,例如恢复生命值带 deltaTime 的 Heartbeat
基于 wait() 的体力循环wait() 已被 task.wait() 取代,而且会被节流,所以可能比要求的等得更久,每次 wait 固定消耗会让体力消耗不均匀每帧根据 deltaTime 消耗和恢复
不检查聊天的 UserInputService.InputBegan在聊天中打字时按 Shift 会触发奔跑ContextActionService,还会添加手机按钮
松开时或每帧设置 WalkSpeed = 16会覆盖任何其他速度,例如游戏通行证福利只在奔跑开始和结束时修改 WalkSpeed,在当前值上增加
通过 RemoteEvent 奔跑,让服务器设置 WalkSpeed作弊者照样自己设置 WalkSpeed,而奔跑会因为往返延迟而晚开始客户端奔跑,加上服务端的距离检查
每个 JumpRequest 都触发二段跳一次跳跃请求 JumpRequest 会触发好几次,而按住的按钮可能持续请求跳跃0.25 秒间隔加新按下检查
用 UserInputService.TouchEnabled 判断“这是手机”在带触摸屏的笔记本上它也是 trueContextActionService 会在触摸设备上添加屏幕按钮,不需要你自己检查设备
用 Humanoid:LoadAnimation 播放奔跑动画已被 Animator:LoadAnimation 取代下面的 奔跑动画 使用 Animator

Roblox 的新方式:Input Action System

Roblox 关于 Input Action System 的页面把角色奔跑作为第一个示例。它不用 BindAction 调用,而是在 Studio 中设置操控:在 ReplicatedStorage 的 input context 里放一个名为 CharacterSprint 的 InputAction,一个 InputBinding 对应 Left Shift,一个对应手柄的 Y 按钮,还有一个关联到你在 StarterGui 中绘制的屏幕按钮。然后客户端脚本监听动作的 Pressed 和 Released 事件,按下时把 WalkSpeed 翻倍,松开时恢复。

如果你想在 Studio 里而不是在代码里布置操控,想用自己的触摸按钮代替 ContextActionService 的按钮,或者需要切换整套操控的上下文(例如菜单或载具),就值得迁移。这个页面还建议把 Workspace.PlayerScriptsUseInputActionSystem 设为 Enabled,而 server authority 要求这样做。

本教程的体力循环和冲刺在只用 Input Action System(不用 server authority)时工作方式一样。保留 MovementConfig、Heartbeat 循环和 dash(),删除两个 BindAction 调用及其处理函数,改为连接动作:奔跑动作的 Pressed 把 sprintHeld 设为 true,它的 Released 设为 false,冲刺动作的 Pressed 调用 dash()。继续像 MovementClient 那样每帧查找 Humanoid,因为文档里的示例保存的是第一个角色的 Humanoid,而重生后它就不存在了。

Roblox 还在测试 Character Controller Library,这是一个需要在 Studio 的 Beta Features 和 Avatar Settings 中开启的测试功能。它关于自定义能力的页面以一个冲刺为例,激活窗口 0.2 秒,冷却 1 秒,也就是和本教程的冲刺相同的时间设定。

怎么扩展:动画、镜头和奔跑通行证

奔跑动画

在 Animation Editor 中做一个奔跑动画,把它的优先级设为 Movement(Roblox 推荐步行和奔跑动画使用它),发布它并复制资源 ID。在 MovementClient 中创建一个 AnimationId 为这个 ID 的 Animation,用角色 Humanoid 里的 Animator 通过 Animator:LoadAnimation 加载它,在奔跑开始的地方播放轨道,在奔跑结束的地方停止。为每个新角色重新加载它。

如果你使用 Roblox 放在那里的 Animator,你的设备在你的角色上播放的动画所有人都能看到:加载到由 LocalScript 创建的 Animator 上的轨道不会复制。许多旧教程使用的 Humanoid:LoadAnimation 已经弃用。

奔跑时镜头更广

稍微宽一点的视野会让奔跑感觉更快。在同样的两个地方,奔跑开始时把 workspace.CurrentCamera.FieldOfView 从默认的 70 补间到大约 80,结束时再补间回来,例如用 TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play()。Roblox 把这个值限制在 1 到 120 之间,并提醒过低或过高的值可能让玩家迷失方向。如果游戏里还有其他脚本修改视野,请补间回你读到的那个值,而不是 70。

快速奔跑作为游戏通行证

游戏通行证教程 已经能和这个脚本配合使用:它的 Speed 福利在服务器上给每个新角色设置 WalkSpeed 24,MovementClient 在此之上加上奔跑加成,每秒 34 stud 仍在 MovementCheck 允许的范围内。

对于让奔跑本身更快的通行证,把一个 FastSprint 通行证加到那个教程的 PassConfig.ids 里。它的服务端脚本会在购买确认后立即给玩家设置 OwnsPass_FastSprint 属性。在 MovementClient 中,当 player:GetAttribute("OwnsPass_FastSprint") == true 时使用比 Config.SPRINT_BONUS 更大的加成。在 MovementCheck 中,通过在服务器上读取同一个属性(玩家无法在那里修改它)给这些玩家更大的允许值,并确认新的最高速度仍低于检查会标记的值。

有一个值得了解的限制:如果另一个脚本在奔跑途中修改了 WalkSpeed,这次奔跑结束时会恢复成奔跑前的速度。下一次重生会重新设置通行证的速度,因为游戏通行证脚本会把它应用到每个新角色上。

常见错误与解决办法

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

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

MovementClient 或 MovementCheck 在等一个名字不完全匹配的模块。它必须是直接放在 ReplicatedStorage 里、名为 MovementConfig 的 ModuleScript。脚本错误教程 详细讲解了这条警告。

按 Shift 没反应

检查 ShiftToSprint 或 MovementClient 是 LocalScript 而不是 Script,并且放在 StarterPlayerScripts 里。使用 MovementClient 时,开始奔跑还需要角色正在走,并且至少有 20 体力,所以请在移动时按住 Shift。如果切换的是 Shift Lock 而不是奔跑,见下面关于 Shift Lock 的问题。

奔跑几秒后就停了

这是体力耗尽了:100 体力以每秒 20 消耗,够跑 5 秒。在 MovementConfig 中调大 MAX_STAMINA 或调小 DRAIN_PER_SECOND。

冲刺没反应

冲刺需要 25 体力,距上次冲刺要等 1 秒,坐着时不起作用。如果都不是这些原因,你角色的根零件可能没有名为 RootAttachment 的 Attachment,有些自定义角色就是这样:把它加到你的 StarterCharacter 的 HumanoidRootPart 里。

二段跳不触发

DoubleJump 必须是 StarterCharacterScripts 中的 LocalScript,而不是放在 StarterPlayerScripts 中,因为它把 script.Parent 当作角色。离地后再按第二次跳跃:按住的按钮不算新的按下,从边缘走下去也不会给空中跳跃。

手机上没有 Sprint 或 Dash 按钮

ContextActionService 只在触摸设备上添加按钮,所以在没有触摸屏的电脑上永远看不到。在 Studio 的 Device Simulator 中用手机测试(这是测试功能:在 File、Beta Features 中开启 New Device Simulator 并重启 Studio)。BindAction 最多只能创建 7 个触摸按钮,所以数一数游戏里其他脚本创建了多少。

MovementCheck 对正常玩家报警

常见原因:来自另一个服务端脚本的传送,传送带或载具,或者延迟。在你自己的传送之后设置 MovementCheckSkip 属性(见 重生和传送),如果检查在正常游戏中仍然触发,就调大 SPEED_ALLOWANCE。

奔跑后加速消失了

另一个脚本在奔跑期间修改了 WalkSpeed,而奔跑结束时恢复了开始时看到的速度。在角色生成时给加速,就像游戏通行证教程那样,这样重生会重新设置正确的速度。

用 RoCode 来做

如果不想手动设置这些,RoCode 可以在你打开的场景里把它搭好。RoCode 是面向 Roblox Studio 的独立 AI 代理,不属于 Roblox:你在网页聊天中描述改动,它的 Studio 插件会在你的 Explorer 中创建脚本,所以不需要粘贴代码。

你输入

加一个按 Shift 奔跑和体力条:按住 Shift 时步行速度加 10,100 体力,每秒消耗 20,休息一秒后每秒恢复 15,手机上有 Sprint 按钮,按 Q 冲刺,还有二段跳。

RoCode 的操作
  • 可以先用 Search Scripts 和 Read Script 浏览你的场景,找出其他修改 WalkSpeed 的脚本(例如游戏通行证福利),让奔跑在它们的基础上增加
  • 用 Create Script 编写 ModuleScript、几个 LocalScript 和服务端检查
  • 它被要求用 Check Script 检查写下的每个脚本能否编译,Check Script 在 Studio 中编译脚本但不运行
  • 在每批改动前后设置撤销点,所以 Ctrl+Z 一次撤销一批

RoCode 不会制作奔跑动画:请在 Animation Editor 中创建并粘贴它的 ID。插件 3.9.11 及以上,RoCode 可以在 Studio 中试玩测试你的游戏,并操控测试角色检查一切是否正常;插件 3.9.15 及以上,测试角色可以按键,例如按住 Shift 并检查 WalkSpeed 是否提高。它自己决定什么时候运行试玩测试,每次构建最多 2 次,再加 1 次检查自己的修复,并且只检查它决定测试的内容,所以奔跑、冲刺和二段跳请自己试一试,手机按钮请在 Studio 的 Device Simulator 中检查。移动只是游戏众多系统中的一个;用 RoCode 做整个游戏 也是像这里一样,每个提示词一个系统。RoCode 如何连接 Studio。

常见问题

奔跑脚本为什么在手机上不起作用?

手机没有 Shift 键。用 ContextActionService:BindAction 绑定奔跑,并把第三个参数设为 true:这会在触摸设备上添加屏幕按钮,ShiftToSprint 和 MovementClient 都是这样做的。

奔跑需要在服务器上做吗?

不需要。每台设备移动自己的角色,所以服务器设置的 WalkSpeed 挡不住可以自己设置速度的作弊者,而且新的速度要经过一次往返才到,奔跑会延迟开始。在客户端做奔跑,在服务器上检查角色实际移动了多远,就像第 5 步那样。Roblox 的 server authority 测试版工作方式不同,移动代码需要为它重写。

我松开了 Shift,角色为什么还在跑?

脚本错过了松开,通常是因为它只监听按下。按键松开时 ContextActionService 会发送 End,被另一个绑定接管时发送 Cancel;MovementClient 在这两种情况下都会停下,体力耗尽或角色停止移动时也会停下。

怎么加奔跑动画?

在同一个 LocalScript 里,通过角色 Humanoid 中的 Animator 加载奔跑动画,奔跑开始时播放,结束时停止。把它的优先级设为 Movement。在你自己角色上播放的动画所有人都能看到。

手机上的二段跳为什么会自己触发?

手机上按住的跳跃按钮会持续请求跳跃。只有当请求短暂停止过,才把跳跃算作新的,DoubleJump 脚本就是这样做的。

Roblox 默认的步行速度是多少?

每秒 16 stud。它来自 StarterPlayer.CharacterWalkSpeed,这个值会设置每个新角色的 Humanoid.WalkSpeed。本教程的奔跑加 10,所以奔跑速度是 26。

Roblox 里奔跑应该多快?

大多数游戏会加上步行速度的一半到一倍:16 变成 24 到 32 之间。短而慢的奔跑适合恐怖游戏,长而快的适合大地图。按游戏类型的预设 给出了每种的步行速度、奔跑加成和体力数值。

怎么做带体力的奔跑?

在玩家的设备上保存一个体力数值,奔跑时每帧消耗它,短暂休息后恢复,两者都根据帧时间计算,数值降到 0 时停止奔跑。第 3 步 的 MovementClient 就是这样做的,还带有屏幕上的体力条;数值放在 MovementConfig 里。

Roblox 里怎么用手柄奔跑?

通过 ContextActionService 把手柄的 ButtonL3(按下左摇杆)和 Left Shift 一起绑定,这里的两个脚本都是这样做的。ShiftToSprint 把 L3 设为切换,因为一边按住摇杆一边用它控制方向很累。

按 Shift 奔跑会和 Shift Lock 冲突吗?

可能会。在 Roblox 设置中开启了 Shift Lock 的玩家用 Shift 键切换它,所以一个键做两件事。Roblox 文档说 Shift Lock 相关的 API 正在被淘汰。如果冲突影响到你的玩家,关闭 StarterPlayer.EnableMouseLockOption,或者在 MovementClient 中把奔跑绑定到另一个键,例如 Left Ctrl。

参考资料

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

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

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