Resumo
Coloque um LocalScript no StarterPlayerScripts que liga uma ação Sprint com ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Enquanto o Shift estiver apertado, some 10 ao Humanoid.WalkSpeed (16 vira 26) e volte ao valor quando soltar. O true adiciona um botão Sprint em telas de toque, e no script deste guia esse botão e o L3 do controle ligam e desligam a corrida em vez de precisarem ficar apertados.
- Some ao WalkSpeed atual em vez de definir 26, para manter um bônus de velocidade vindo de um game pass.
- A corrida roda no dispositivo do jogador. O servidor não consegue impor um WalkSpeed; ele só consegue medir quanto os personagens andam e sinalizar velocidades que a corrida não explica.
- Para uma barra de stamina, um dash ou um pulo duplo, os Passos 2 a 4 usam a mesma ideia. Para saber quão rápido e por quanto tempo, os presets por tipo de jogo trazem números para terror, combate e mundo aberto.
Nesta página
Como a corrida funciona no Roblox
O dispositivo de cada jogador move o personagem daquele jogador. O teclado, o controle ou a tela de toque decide para onde o personagem vai, e o Roblox repassa o resultado para o servidor e para todos os outros. Então uma corrida é um LocalScript que aumenta o Humanoid.WalkSpeed enquanto uma tecla está apertada, e é só isso que o Passo 1 faz. O resto deste guia é o que um jogo maior precisa em volta disso: uma barra de stamina, um dash, um pulo duplo e uma checagem no servidor para jogadores que trapaceiam.
| Peça | Onde fica | O que faz |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | O Passo 1 sozinho: corrida no teclado, no celular e no controle, sem stamina. O MovementClient o substitui quando você adiciona stamina e um dash. |
ModuleScript MovementConfig | ReplicatedStorage | Os números: bônus de corrida, stamina e dash. O LocalScript e a checagem do servidor leem os dois. |
LocalScript MovementClient | StarterPlayerScripts | Liga Sprint e Dash a uma tecla, a um botão do controle e a um botão de toque, roda o loop de stamina, desenha a barra e faz o dash. |
LocalScript DoubleJump | StarterCharacterScripts | Dá um pulo extra no ar. Uma cópia nova roda em cada personagem novo. |
Script MovementCheck | ServerScriptService | Mede quanto cada personagem anda de verdade e avisa no Output quando alguém continua mais rápido do que a corrida e o dash permitem. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Se a divisão entre Script e LocalScript é novidade para você, o guia Script vs LocalScript vs ModuleScript (em inglês) explica onde cada tipo roda e por quê.
Passo 1: Correr com Shift em um LocalScript
Se tudo o que você precisa é correr mais rápido enquanto o Shift está apertado, este script basta. Ele também dá aos celulares um botão Sprint na tela e deixa o controle correr com o analógico esquerdo.
- No Explorer, expanda StarterPlayer, passe o mouse sobre StarterPlayerScripts, clique no botão + e insira um LocalScript chamado
ShiftToSprint. - Troque o conteúdo dele pelo código abaixo e aperte Play.
-- LocalScript em StarterPlayer > StarterPlayerScripts, chamado ShiftToSprint.
-- Segure Left Shift para correr. Em um controle, clique o analógico esquerdo (L3) para ligar
-- e desligar a corrida. No celular, toque o botão Sprint para ligar e desligar a corrida.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Configurações
local SPRINT_BONUS = 10 -- somado ao WalkSpeed durante a corrida (16 vira 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: segurar o botão em vez de alternar
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- o WalkSpeed para onde voltar
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
-- Guarda a velocidade atual e soma a ela, para manter um bônus de velocidade de outro lugar
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
-- Segurar: corre enquanto a tecla ou o botão estiver apertado
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
-- Alternar: cada aperto liga ou desliga a corrida
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Uma chamada liga a tecla, o botão do controle e, em telas de toque, um botão na tela
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- Um personagem novo começa andando: o Humanoid dele já tem o WalkSpeed normal
player.CharacterAdded:Connect(function()
sprinting = false
end)
Mude o SPRINT_BONUS para uma corrida mais rápida ou mais lenta. Defina TOGGLE_ON_TOUCH_AND_GAMEPAD como false para o botão do celular e o L3 funcionarem como o Shift: correr só enquanto estiverem apertados.
O BindAction liga uma ação ao Left Shift e ao botão L3 do controle, e o terceiro argumento dele, true, adiciona um botão na tela em telas de toque; o SetTitle escreve "Sprint" nele. O handler também recebe a entrada, então consegue diferenciar um aperto no teclado do controle ou do botão de toque. Quando a corrida começa, o script guarda o WalkSpeed atual e soma o SPRINT_BONUS; quando ela para, ele devolve o valor guardado. Uma velocidade definida por outro script, como o bônus Speed do guia de game pass (em inglês), é mantida. Um personagem novo começa no WalkSpeed normal, então o handler do CharacterAdded só limpa a flag.
Segurar ou alternar?
| Dispositivo e entrada | Funciona como | Por quê |
|---|---|---|
| Teclado: Left Shift | Segurar | Segurar uma tecla enquanto anda é fácil, e soltar para a corrida na hora. |
| Controle: clicar o analógico esquerdo (L3) | Alternar | Segurar o analógico apertado enquanto você usa ele para andar cansa. |
| Celular ou tablet: o botão Sprint na tela | Alternar | Um polegar que segura o botão não consegue apertar Jump ao mesmo tempo. |
Para testar, aperte Play e segure Shift enquanto anda: você acelera de 16 para 26 studs por segundo, e solta para desacelerar. Para celular, escolha um celular no Device Simulator do Studio, aperte Play e toque em Sprint uma vez para começar e outra para parar. Para controle, abra o Controller Emulator durante o teste e clique L3. O Passo 6 tem a lista completa de dispositivos.
Os Passos 2 e 3 trocam este script por um que adiciona uma barra de stamina e um dash. Os Passos 4 e 5 adicionam um pulo duplo e uma checagem no servidor, e funcionam com qualquer um dos dois scripts.
Passo 2: Coloque os números de stamina e dash em um módulo
Para uma corrida que acaba, os Passos 2 e 3 trocam o ShiftToSprint por um LocalScript maior com barra de stamina e dash. Apague o ShiftToSprint antes: os dois ligam a ação Sprint.
Todos os números ficam em um ModuleScript, então você ajusta a sensação em um lugar só. O MovementClient lê esses números no dispositivo de cada jogador, e o MovementCheck lê o mesmo módulo no servidor para saber quão rápidos uma corrida e um dash devem ser.
- No Explorer, passe o mouse sobre ReplicatedStorage, clique no botão + e insira um ModuleScript.
- Renomeie para
MovementConfige troque o conteúdo dele pelo código abaixo.
-- Um conjunto de números para o LocalScript de movimento e para a checagem de velocidade do servidor.
local MovementConfig = {
SPRINT_BONUS = 10, -- somado ao WalkSpeed atual: 16 (o padrão do Roblox) vira 26
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 segundos de corrida com a barra cheia
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- segundos depois de parar de correr até a stamina voltar
MIN_TO_START = 20, -- stamina necessária para começar a correr, para uma barra vazia não piscar liga e desliga
DASH_SPEED = 60, -- studs por segundo durante um dash
DASH_SECONDS = 0.2, -- então um dash cobre cerca de 12 studs
DASH_COST = 25, -- stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Configuração | Valor | Efeito |
|---|---|---|
SPRINT_BONUS | 10 | Somado ao WalkSpeed durante a corrida. O WalkSpeed padrão do Roblox é 16, então a corrida vai a 26 studs por segundo. |
MAX_STAMINA | 100 | Uma barra cheia. |
DRAIN_PER_SECOND | 20 | Uma barra cheia dura 5 segundos de corrida. |
REGEN_PER_SECOND | 15 | Uma barra vazia leva cerca de 6,7 segundos para encher. |
REGEN_DELAY | 1 | Segundos de descanso antes de a barra começar a encher. |
MIN_TO_START | 20 | Stamina necessária para começar uma corrida. |
DASH_SPEED | 60 | Studs por segundo durante um dash. |
DASH_SECONDS | 0.2 | Quanto um dash dura: cerca de 12 studs a 60 studs por segundo. |
DASH_COST | 25 | Stamina que cada dash gasta. |
DASH_COOLDOWN | 1 | Segundos entre dashes. |
Cada lado roda a própria cópia de um módulo (um módulo roda uma vez por lado (em inglês)), então um jogador que edita esses números no próprio dispositivo muda só a cópia dele. Mas isso não protege nada aqui: o dispositivo dele já move o personagem dele, então ele pode se dar stamina infinita, diga o módulo o que disser. A checagem do servidor no Passo 5 foi feita pensando nisso.
Passo 3: Corrida com stamina, e dash
Este LocalScript faz o trabalho que os jogadores sentem. Ele liga Sprint e Dash, desenha a barra de stamina, roda o loop de stamina a cada frame e faz o dash.
- No Explorer, expanda StarterPlayer, passe o mouse sobre StarterPlayerScripts e insira um LocalScript chamado
MovementClient. - Troque o conteúdo dele pelo código abaixo.
-- Segure Shift (ou L3, ou o botão Sprint no celular) para correr enquanto houver stamina.
-- Aperte Q (ou B, ou o botão Dash) para dar um dash na direção em que você está andando.
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 -- o WalkSpeed para onde voltar quando a corrida para
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Barra de stamina: um frame com um preenchimento cuja largura é a stamina que sobra
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
-- Sprint: aqui é só uma flag; o loop do Heartbeat abaixo decide a cada frame se corre
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Só um aperto ou uma soltura muda isso: um dedo deslizando no botão de toque manda 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()
-- Sem dash sentado: um personagem sentado está soldado ao assento, então empurraria o veículo inteiro
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 -- pausa o preenchimento, como a corrida faz
-- Dash na direção em que o jogador anda, ou para onde ele olha se estiver parado
local direction = humanoid.MoveDirection
if direction.Magnitude < 0.1 then
direction = rootPart.CFrame.LookVector
end
direction = Vector3.new(direction.X, 0, direction.Z).Unit
-- LinearVelocity no modo Plane segura a velocidade horizontal e deixa a gravidade em paz
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
-- Cada chamada liga uma tecla, um botão do controle e, em dispositivos de toque, um botão na tela
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")
-- A cada frame: gasta stamina enquanto corre e anda, enche de novo depois de um descanso curto
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
-- Muda o WalkSpeed só quando a corrida começa ou para, para que uma velocidade definida por
-- outro script (como um passe de velocidade) seja mantida e a corrida some a ela
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)
-- Um personagem novo começa com a stamina cheia e nada apertado
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- o Humanoid novo começa no WalkSpeed normal
end)
A barra de stamina é criada no código com ResetOnSpawn como false, então ela fica na tela depois de cada respawn, e o handler do CharacterAdded no final enche a barra de novo para cada personagem novo. As linhas do type Config descrevem o que o módulo devolve, para a checagem de tipos strict pegar uma configuração escrita errado; elas não mudam nada quando o jogo roda.
Teclado, controle e um botão no celular com uma chamada
O ContextActionService:BindAction recebe o nome de uma ação, uma função handler, se deve criar um botão de toque e depois as entradas. Passar true como terceiro argumento faz o ContextActionService adicionar um botão na tela em dispositivos com toque, dentro de uma ScreenGui chamada ContextActionGui no PlayerGui do jogador. O SetTitle escreve "Sprint" e "Dash" nesses botões. O BindAction cria no máximo 7 botões de toque, então fique de olho se outros scripts do seu jogo também usam.
O handler recebe o estado da entrada: Begin em um aperto e End na soltura. O onSprint só registra se o Sprint está apertado. Ele também trata Cancel como soltura, que o ContextActionService manda quando outra ligação toma conta da entrada, e ignora Change, que um dedo andando no botão de toque pode mandar. Os dois handlers devolvem Pass, então a próxima ligação na mesma tecla ainda recebe a entrada.
A referência do ContextActionService da Roblox o recomenda no lugar do UserInputService.InputBegan na maioria dos casos. O exemplo dela é uma buzina de carro no H que não deve buzinar enquanto o jogador digita no chat: uma ligação só dispara enquanto for a mais recente para aquela entrada, então quando a caixa do chat pega o teclado você não precisa conferir nada. As entradas do controle são ButtonL3 (apertar o analógico esquerdo, segurado enquanto você anda) e ButtonB. O exemplo de corrida da própria Roblox usa ButtonY, então mude o KeyCode no BindAction se isso combinar mais com o seu jogo.
O loop de stamina
O RunService.Heartbeat dispara a cada frame depois do passo de física e passa o deltaTime, os segundos desde o frame anterior. Multiplicar as taxas de gasto e de preenchimento por ele faz uma barra cheia durar 5 segundos, rode o jogo a 30 ou a 240 frames por segundo.
A cada frame o loop decide se o personagem deve estar correndo: o Sprint está apertado, o personagem está andando (o Humanoid.MoveDirection é um vetor zero quando não está) e ainda sobra stamina. Começar uma corrida exige pelo menos MIN_TO_START (20); manter uma exige qualquer coisa acima de 0. Sem essa diferença, uma barra vazia que enche um pouquinho a cada frame ligaria e desligaria a corrida a cada frame. O preenchimento começa REGEN_DELAY (1 segundo) depois da última corrida ou do último dash, então depois de esvaziar a barra o jogador espera cerca de 2,3 segundos antes de poder correr de novo.
O WalkSpeed muda só no frame em que uma corrida começa ou para. No começo o script guarda o WalkSpeed atual e soma o SPRINT_BONUS; no fim ele devolve o valor guardado. É por isso que uma velocidade definida por outro script sobrevive: o bônus Speed do guia de game pass (em inglês) define o WalkSpeed como 24, e com este script os donos do passe correm a 34. Um script que escreve WalkSpeed = 16 a cada frame, ou a cada soltura, cancelaria esse bônus sem avisar.
O dash
O dash empurra o personagem na direção em que ele anda, ou para onde ele olha quando está parado, achatada para nunca apontar para cima ou para baixo. Ele custa 25 de stamina, pausa o preenchimento como a corrida faz e tem um cooldown de 1 segundo. Nada nele confere o chão, então ele também funciona no ar, o que combina bem com o pulo duplo. Ele não faz nada enquanto o personagem está sentado: um personagem sentado está soldado ao assento, então em um veículo o empurrão poderia jogar o veículo inteiro.
O empurrão é uma constraint LinearVelocity no RootAttachment da root part. No modo Plane com os eixos X e Z, ela segura a velocidade horizontal em 60 studs por segundo e deixa a direção vertical em paz, então a gravidade continua funcionando e um dash para fora de uma borda cai normalmente. O MaxForce é math.huge, então o empurrão não tem limite. O Debris:AddItem destrói a constraint depois de DASH_SECONDS sem fazer o script esperar, então o dash dura 0,2 segundo, cerca de 12 studs nessa velocidade.
Tutoriais mais antigos usam BodyVelocity, que a Roblox marca como deprecated com a nota de usar LinearVelocity no lugar. O truque dele de zerar o MaxForce em um eixo é o que os modos Line, Plane e Vector do LinearVelocity substituem. Como o dispositivo do jogador simula o próprio personagem, a constraint que o LocalScript cria o move, e os outros jogadores veem o dash como qualquer outro movimento.
O tutorial de UI da própria Roblox prende uma constraint em humanoid.RootPart.RootAttachment do mesmo jeito. Se o seu jogo usa um personagem personalizado cuja root part não tem um Attachment chamado RootAttachment, o dash não faz nada: adicione um ao HumanoidRootPart do seu StarterCharacter.
Passo 4: Adicione um pulo duplo
O pulo duplo fica no próprio LocalScript dele, no StarterCharacterScripts. O Roblox coloca uma cópia dos scripts desse container em cada personagem quando ele nasce, e essas cópias não sobrevivem a um respawn, então cada vida começa com um script novo e nada vem da anterior.
- No Explorer, expanda StarterPlayer, passe o mouse sobre StarterCharacterScripts e insira um LocalScript chamado
DoubleJump. - Troque o conteúdo dele pelo código abaixo.
-- Dá um pulo extra no ar. Ele roda de novo para cada personagem novo,
-- então nada fica de uma vida para a outra depois de um respawn.
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 dispara várias vezes para um aperto só
local NEW_PRESS_GAP = 0.1 -- um botão de pulo segurado continua disparando JumpRequest; uma pausa desse tamanho quer dizer que foi solto
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
-- Um pulo do chão (não um dos nossos pulos no ar) recarrega os pulos no ar
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- JumpRequest dispara sempre que o jogador pede para pular, como com Espaço ou o botão de pulo do celular
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Só um aperto novo pula de novo, então segurar o botão não gasta o pulo no ar
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)
Defina EXTRA_JUMPS como 2 para um pulo triplo.
O script acompanha o estado do personagem com Humanoid.StateChanged. Uma mudança para Jumping que não veio de Freefall é um pulo do chão, então ela dá o pulo no ar, e o Landed tira ele de novo. Sair andando de uma borda vai para Freefall sem pulo, então não dá pulo no ar. Se você quer um ali também, defina o jumpsLeft também quando o estado mudar para Freefall vindo de qualquer coisa que não seja Jumping.
O UserInputService.JumpRequest dispara quando o jogador pede para pular, por exemplo com Espaço ou com o botão de pulo no celular. A referência da Roblox avisa que ele dispara várias vezes para um único pedido de pulo e recomenda um debounce, então o script ignora pedidos a menos de 0,25 segundo do último pulo. Segurar o botão de pulo também pode continuar pedindo pulos, o que gastaria o pulo no ar no momento em que o personagem sai do chão, então um pedido só conta como aperto novo depois de 0,1 segundo sem nenhum.
O pulo no ar em si é Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). A referência da Roblox diz que ele precisa ser chamado de um LocalScript em um dispositivo que tem a network ownership do personagem, que por padrão é o dispositivo do próprio jogador, não o servidor. O exemplo de código dela para ChangeState é um pulo duplo.
Passo 5: Sinalize hacks de velocidade no servidor
Tutoriais de corrida costumam parar no cliente. Um Script de servidor não pode confiar no WalkSpeed de um jogador, porque exploiters o mudam no próprio dispositivo, mas ele consegue ver onde o personagem vai parar. O MovementCheck mede isso duas vezes por segundo e avisa no Output quando alguém continua andando mais rápido do que a corrida e o dash permitem. Ele lê os números de corrida e de dash do MovementConfig, então adicione esse módulo do Passo 2 mesmo se você ficou com o ShiftToSprint.
- Passe o mouse sobre ServerScriptService e insira um Script chamado
MovementCheck. - Troque o conteúdo dele pelo código abaixo.
-- Os dispositivos dos jogadores movem os próprios personagens, então um exploiter pode definir qualquer WalkSpeed.
-- Esta checagem mede quanto cada personagem anda de verdade e avisa no Output
-- quando alguém continua mais rápido do que a corrida e o dash permitem. Ela só avisa:
-- lag, teleportes e esteiras podem parecer excesso de velocidade, então ajuste antes de punir alguém.
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 -- segundos
-- Velocidade de corrida mais uma folga para lag. Aumente se você vende bônus de velocidade.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- folga para um ou dois dashes
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- quão rápido as rajadas passadas são perdoadas
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- a root part em que lastPosition foi medida
local excess: { [Player]: number } = {} -- studs andados além da folga, perdoados aos poucos
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
-- Um respawn é uma root part nova, e um teleporte do servidor (início de rodada, checkpoint)
-- define o atributo abaixo: começa a medir de novo em vez de sinalizar o salto
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
-- Só movimento horizontal: cair rápido não é trapaça
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
O aviso aparece no Output do Studio. Em um jogo publicado ele vai para o log do servidor no Developer Console, que você consegue ler como dono do jogo: veja o Output em um jogo publicado.
O que ela mede
A cada meio segundo o script lê a posição da root part de cada personagem e mede quanto ela andou para os lados desde a última checagem. A altura é ignorada, então cair ou pular nunca conta; a orientação de validação de movimento da Roblox sugere a mesma projeção no plano XZ para jogos baseados no chão. A folga é a velocidade de andar padrão mais o bônus de corrida, mais um quarto para lag: 32,5 studs por segundo. A distância além disso vai para um leaky bucket (balde furado), um tipo de acumulador que a documentação da Roblox diz que muitos desenvolvedores acham bom para movimentos em rajada. O balde perde 3 studs a cada checagem, e o script avisa quando ele passa de 24 studs, o que dá espaço para uns dois dashes.
| Um trapaceiro | O que o MovementCheck faz |
|---|---|
| Define o WalkSpeed como 100 | Avisa em cerca de um segundo de corrida |
| Define o WalkSpeed como 50 | Avisa depois de cerca de 2,5 segundos de corrida |
| Encadeia dashes sem cooldown (60 studs por segundo) | Avisa depois de cerca de 1,5 segundo |
| Se teleporta mais de cerca de 43 studs de uma vez | Avisa na próxima checagem |
| Corre a até 38 studs por segundo, cerca de uma vez e meia a velocidade da corrida | Nada: abaixo de 38,5 studs por segundo o balde esvazia tão rápido quanto enche |
| Edita o próprio MovementConfig para ter stamina infinita | Nada: uma corrida a 26 studs por segundo é permitida por quanto tempo durar |
| Voa, pula sem limite ou atravessa paredes | Nada: a checagem ignora a altura e não olha colisões |
Então a checagem pega as trapaças grosseiras, as que deixam um jogador claramente mais rápido do que todo mundo, e deixa passar as cuidadosas. Esse é o limite honesto de uma checagem de distância, e o motivo de a Roblox estar construindo algo mais forte (veja server authority abaixo).
Por que ela só avisa
A documentação da Roblox lembra que checagens simples de velocidade podem sinalizar jogadores inocentes com conexão instável e falham em jogos com veículos ou outros movimentos complexos. Picos de lag, esteiras, veículos, explosões que arremessam personagens e os seus próprios teleportes podem parecer excesso de velocidade, então o script só imprime um aviso. Olhe o Output enquanto você e seus testers jogam normalmente, aumente o SPEED_ALLOWANCE se jogadores honestos dispararem o aviso, e só adicione uma punição, como mover o jogador de volta, quando a checagem ficar quieta em jogo normal. Se explosões arremessam personagens no seu jogo, pule também os jogadores cujo Humanoid não tem mais vida.
Respawns e teleportes
Um respawn cria uma root part nova, e o script começa a medir de novo quando vê uma, então morrer longe do ponto de spawn nunca conta como excesso de velocidade. Teleportes feitos pelos seus próprios scripts de servidor precisam de uma exceção, como a documentação da Roblox diz para qualquer jogo com mecânicas de teleporte. Depois do teleporte, adicione player:SetAttribute("MovementCheckSkip", true), e a próxima checagem começa a medir da nova posição em vez de sinalizar o salto:
- No sistema de rounds, logo depois do
character:PivotTo(...)nostartRound. - No script de checkpoint de obby (em inglês), logo depois de cada
character:PivotTo(...)que leva um jogador ao checkpoint dele.
As plataformas e o menu do guia de teleporte, e a plataforma Finish do guia do primeiro jogo, já definem o atributo depois de cada movimento.
Só o valor do servidor conta. Um atributo que um jogador define no próprio dispositivo fica naquele dispositivo (veja o que replica e o que não replica (em inglês)), então um trapaceiro não consegue usá-lo para desligar a checagem.
A solução de longo prazo: server authority
A documentação de segurança da Roblox chama o modelo de server authority, em beta quando este guia foi escrito, de jeito mais confiável de impedir exploits de movimento. O servidor vira a fonte da verdade e os dispositivos dos jogadores só informam as entradas deles, o que, segundo a documentação, impede speed hacks porque nunca se confia em um dispositivo para informar a própria posição.
Mudar para ele é reescrever, não ligar uma configuração. Nesse modelo o servidor roda o movimento, então um WalkSpeed ou um LinearVelocity que só um LocalScript define é desfeito quando o estado do servidor chega. A documentação da Roblox diz que a lógica principal precisa rodar em funções RunService:BindToSimulation() dentro de um ModuleScript que tanto o cliente quanto o servidor rodam. O modelo também precisa de várias configurações do Workspace, incluindo PlayerScriptsUseInputActionSystem, então os seus controles também iriam para o Input Action System. Fique com a versão deste guia até levar a corrida, a stamina e o dash para essa estrutura. Até lá, uma checagem de distância como esta é o que a seção de validação de movimento da Roblox descreve.
Passo 6: Teste em todo dispositivo
- Aperte Play e segure Shift enquanto anda. Você acelera de 16 para 26 studs por segundo e a barra verde embaixo da tela diminui. Depois de cerca de 5 segundos ela fica vazia e você volta à velocidade de andar.
- Solte o Shift. Depois de 1 segundo a barra começa a encher de novo. Até ela chegar a um quinto, segurar Shift não faz nada.
- Aperte Q enquanto anda: você dispara um pouco para a frente e some um quarto da barra. Aperte Q de novo na hora e nada acontece até passar um segundo. Se o dash parecer curto ou longo demais, mude
DASH_SPEEDouDASH_SECONDSno MovementConfig. - Pule e aperte pular de novo no ar para um segundo pulo. Caia no chão e tente de novo: cada pulo do chão devolve o pulo no ar.
- Segure Espaço durante um pulo inteiro. Você deve ter um pulo, não dois, porque o pulo no ar precisa de um aperto novo.
- Ligue o Device Simulator do Studio (um beta quando este guia foi escrito: File, Beta Features, New Device Simulator, depois reinicie o Studio), ou ligue o Device Emulator antigo no menu Test. Escolha um celular e aperte Play. Aparecem os botões Sprint e Dash. Segure Sprint enquanto anda, depois segure o botão de pulo durante um pulo e confira que você tem só um pulo.
- Abra o Controller Emulator (Controller na aba Emulation, ou Virtual controller na barra de ferramentas do Device Simulator). Segure L3 enquanto anda para correr, aperte B para o dash e aperte A duas vezes para o pulo duplo.
- Resete o personagem pelo menu do jogo. A barra está cheia de novo, o Output não mostra nenhum aviso do MovementCheck e, se você ainda está simulando um celular, os botões Sprint e Dash continuam lá.
- Agora faça o papel do trapaceiro. Clique no botão Client/Server até o Explorer mostrar o cliente, selecione o Humanoid do seu personagem no Workspace e defina WalkSpeed como 60 na janela Properties. Ande por alguns segundos: o Output mostra um aviso como
MovementCheck: YourName moved 60 studs/s. Volte para 16, depois corra e dê dashes normalmente por um minuto e confira que o Output fica quieto. - Se o seu place tem
Workspace.PlayerScriptsUseInputActionSystemcomo Enabled, teste o pulo duplo de novo: a documentação da Roblox não diz se oJumpRequestse comporta igual com ele.
Se nada acontecer, abra a janela Output pelo menu Window do Studio e procure um erro vermelho do MovementClient, ou veja os erros comuns.
Quão rápido e por quanto tempo: presets por tipo de jogo
A corrida certa depende do jogo. Uma perseguição de terror pede uma corrida curta e lenta que acaba na pior hora; um mapa aberto grande pede uma longa, para os jogadores não se entediarem atravessando. Estes presets usam os mesmos scripts e mudam só a velocidade de andar e o MovementConfig. São os nossos pontos de partida, calculados a partir das configurações, não medidos com jogadores.
| Tipo de jogo | CharacterWalkSpeed | SPRINT_BONUS (velocidade de corrida) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Corrida cheia | De vazia a cheia | Distância com uma barra |
|---|---|---|---|---|---|---|---|
| Este guia | 16 | 10 (26) | 20 | 15 | 5 s | 7,7 s | 130 studs |
| Perseguição de terror | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 studs |
| Battlegrounds e combate | 16 | 12 (28) | 15 | 20 | 6,7 s | 6 s | cerca de 187 studs |
| Mundo aberto ou simulador | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 studs |
| Obby ou parkour | 16 | 8 (24) | sem stamina: use o ShiftToSprint |
- A velocidade de andar fica no StarterPlayer. Selecione StarterPlayer e defina
CharacterWalkSpeed(16 por padrão). Todo personagem novo começa nessa velocidade, a corrida somaSPRINT_BONUSa ela, e o MovementCheck também a lê, então a checagem do servidor acompanha a sua escolha. - O MovementCheck se adapta. Ele permite a velocidade de andar mais o bônus de corrida, mais um quarto para lag: 25 studs por segundo no preset de terror, 40 no de mundo aberto. Nada mais precisa mudar.
- Em um obby, a corrida muda o percurso. Uma corrida mais rápida passa buracos maiores. Monte os pulos e teste cada um na velocidade de corrida, senão a corrida deixa as fases fáceis demais. O guia de checkpoints de obby (em inglês) combina com o ShiftToSprint.
- Em um jogo de terror, o assassino é a referência. Deixe quem persegue um pouco mais rápido do que a velocidade de andar e um pouco mais lento do que a corrida, para escapar depender de quando a barra acaba. O guia de jogo de terror cobre o resto do loop.
O que scripts de corrida antigos fazem errado
Tutoriais antigos de corrida, dash e pulo duplo muitas vezes ainda rodam, mas muitos usam padrões que a Roblox já substituiu, ou quebram outros sistemas do seu jogo. Se você está consertando um script que copiou, confira com esta lista.
| Padrão | Por que é um problema | Este guia |
|---|---|---|
BodyVelocity para um dash | Deprecated: a Roblox diz para usar LinearVelocity no lugar | LinearVelocity no modo Plane |
Um loop no RunService.RenderStepped | Substituído pelo PreRender para código novo. Lógica de jogo como a stamina fica no Heartbeat, que a Roblox descreve para tarefas periódicas como regenerar vida | Heartbeat com deltaTime |
Um loop de stamina feito com wait() | O wait() está deprecated em favor do task.wait(), e ele é limitado, então pode esperar mais do que o pedido e um valor fixo por espera gasta de forma irregular | Gasto e preenchimento escalados pelo deltaTime a cada frame |
UserInputService.InputBegan sem checar o chat | Apertar Shift enquanto digita uma mensagem no chat começa uma corrida | ContextActionService, que também adiciona o botão do celular |
Definir WalkSpeed = 16 na soltura ou a cada frame | Sobrescreve qualquer outra velocidade, como um bônus de game pass | Muda o WalkSpeed só quando uma corrida começa ou para, somando ao valor atual |
| Correr por um RemoteEvent para o servidor definir o WalkSpeed | Exploiters definem o próprio WalkSpeed de qualquer jeito, e a corrida começa uma ida e volta atrasada | Corrida no cliente, mais uma checagem de distância no servidor |
Um pulo duplo a cada JumpRequest | O JumpRequest dispara várias vezes para um pedido de pulo, e um botão segurado pode continuar pedindo pulos | Uma pausa de 0,25 segundo e uma checagem de aperto novo |
UserInputService.TouchEnabled como checagem de "é celular" | Ele é true em notebooks com tela de toque | O ContextActionService adiciona os botões na tela em dispositivos com toque, sem você precisar checar o dispositivo |
Humanoid:LoadAnimation para uma animação de corrida | Deprecated em favor do Animator:LoadAnimation | A animação de corrida abaixo usa o Animator |
O jeito mais novo da Roblox: o Input Action System
A página do Input Action System da Roblox usa uma corrida de personagem como primeiro exemplo. Em vez de chamadas de BindAction, você monta os controles no Studio: uma InputAction chamada CharacterSprint dentro de um input context no ReplicatedStorage, com um InputBinding para o Left Shift, um para o botão Y do controle e um ligado a um botão na tela que você desenha no StarterGui. Um script de cliente então escuta os eventos Pressed e Released da ação, dobrando o WalkSpeed no aperto e voltando ao valor na soltura.
Vale a pena mudar quando você quer os controles montados no Studio em vez de no código, o seu próprio botão de toque em vez do botão do ContextActionService, ou contextos que trocam conjuntos inteiros de controles, como um menu ou um veículo. A página também recomenda definir Workspace.PlayerScriptsUseInputActionSystem como Enabled, e o server authority exige isso.
O loop de stamina e o dash deste guia funcionam do mesmo jeito com o Input Action System sozinho (sem server authority). Mantenha o MovementConfig, o loop do Heartbeat e o dash(), apague as duas chamadas de BindAction e os handlers delas, e conecte as ações no lugar: o Pressed da ação de corrida define sprintHeld como true e o Released dela define como false, e o Pressed da ação de dash chama dash(). Continue buscando o Humanoid a cada frame como o MovementClient faz, porque o exemplo da documentação guarda o Humanoid do primeiro personagem, que some depois de um respawn.
A Roblox também está testando uma Character Controller Library, um beta que você liga nas Beta Features e nas Avatar Settings do Studio. A página de habilidades personalizadas dela monta um dash como exemplo, com uma janela ativa de 0,2 segundo e um cooldown de 1 segundo, o mesmo tempo do dash deste guia.
Indo além: animação, câmera e um passe de corrida
Uma animação de corrida
Faça uma animação de corrida no Animation Editor, defina a prioridade dela como Movement (a prioridade que a Roblox recomenda para animações de andar e correr), publique e copie o asset ID dela. No MovementClient, crie uma Animation com esse AnimationId, carregue com Animator:LoadAnimation usando o Animator dentro do Humanoid do personagem, toque a track onde a corrida começa e pare onde a corrida para. Carregue de novo para cada personagem novo.
Animações que o seu dispositivo começa no seu próprio personagem aparecem para todo mundo, desde que você use o Animator que o Roblox colocou ali: tracks carregadas em um Animator que um LocalScript criou não replicam. O Humanoid:LoadAnimation, que muitos tutoriais antigos usam, está deprecated.
Abrir a câmera durante a corrida
Um campo de visão um pouco mais aberto faz a corrida parecer mais rápida. Nos mesmos dois lugares, faça um tween de workspace.CurrentCamera.FieldOfView do padrão 70 para cerca de 80 quando a corrida começa e de volta quando ela para, por exemplo com TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). O Roblox limita o valor entre 1 e 120 e avisa que valores muito baixos ou muito altos podem desorientar os jogadores. Se outro script do seu jogo também muda o campo de visão, volte para o valor que você encontrou em vez de 70.
Uma corrida mais rápida como game pass
O guia de game pass (em inglês) já funciona com este script: o bônus Speed dele define o WalkSpeed como 24 no servidor para cada personagem novo, o MovementClient soma o bônus de corrida por cima, e 34 studs por segundo fica dentro do que o MovementCheck permite.
Para um passe que deixa a própria corrida mais rápida, adicione um passe FastSprint ao PassConfig.ids daquele guia. O script de servidor dele então define o atributo OwnsPass_FastSprint no jogador quando o passe é confirmado. No MovementClient, use um bônus maior do que Config.SPRINT_BONUS quando player:GetAttribute("OwnsPass_FastSprint") == true. No MovementCheck, dê a esses jogadores uma folga maior, lendo o mesmo atributo no servidor, onde um jogador não consegue mudá-lo, e confira que a nova velocidade máxima fica abaixo do que a checagem sinaliza.
Um limite para saber: se outro script muda o WalkSpeed no meio de uma corrida, o fim dessa corrida devolve a velocidade de antes dela. O próximo respawn define a velocidade do passe de novo, porque o script de game pass a aplica a cada personagem novo.
Erros comuns e como resolver
Abra a janela Output (menu Window, depois Output) antes de apertar Play. A maioria dos problemas com estes scripts imprime um erro ou um aviso ali, com o nome do script e a linha.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
O MovementClient ou o MovementCheck está esperando um módulo que não existe com esse nome exato. Ele precisa ser um ModuleScript chamado MovementConfig direto dentro do ReplicatedStorage. O guia de erros de script explica esse aviso em detalhe.
Segurar Shift não faz nada
Confira se o ShiftToSprint ou o MovementClient é um LocalScript, não um Script, e se ele está no StarterPlayerScripts. Com o MovementClient, uma corrida também exige que o personagem esteja andando e tenha pelo menos 20 de stamina para começar, então segure Shift enquanto anda. Se o Shift Lock liga em vez disso, veja a pergunta sobre Shift Lock abaixo.
A corrida para depois de alguns segundos
É a stamina acabando: 100 de stamina gastando 20 por segundo dura 5 segundos. Aumente o MAX_STAMINA ou diminua o DRAIN_PER_SECOND no MovementConfig.
O dash não faz nada
Um dash precisa de 25 de stamina, espera 1 segundo depois do último e não faz nada enquanto você está sentado. Se nada disso for o problema, a root part do seu personagem pode não ter um Attachment chamado RootAttachment, o que acontece com alguns personagens personalizados: adicione um ao HumanoidRootPart do seu StarterCharacter.
O pulo duplo nunca acontece
O DoubleJump precisa ser um LocalScript no StarterCharacterScripts, não no StarterPlayerScripts, porque ele lê o script.Parent como o personagem. Aperte pular uma segunda vez depois de sair do chão: segurar o botão não conta como aperto novo, e sair andando de uma borda não dá pulo no ar.
Não aparece botão Sprint nem Dash no celular
O ContextActionService só adiciona os botões dele em dispositivos com toque, então eles nunca aparecem em um PC sem tela de toque. Teste com um celular no Device Simulator do Studio (um beta: ligue New Device Simulator em File, Beta Features, e reinicie o Studio). O BindAction cria no máximo 7 botões de toque, então conte quantos outros scripts do seu jogo criam botões.
O MovementCheck avisa sobre jogadores honestos
As causas comuns são um teleporte feito por outro script de servidor, uma esteira ou um veículo, ou lag. Defina o atributo MovementCheckSkip depois dos seus próprios teleportes (veja Respawns e teleportes), e aumente o SPEED_ALLOWANCE se ele ainda disparar em jogo normal.
Um bônus de velocidade some depois de correr
Outro script mudou o WalkSpeed durante a corrida, e a corrida terminou devolvendo a velocidade que viu quando começou. Aplique bônus de velocidade quando o personagem nasce, como o guia de game pass faz, para um respawn definir a velocidade certa de novo.
Crie com o RoCode
Se você prefere não montar isso à mão, o RoCode pode construir tudo no place que você tem aberto. O RoCode é um agente de IA independente para Roblox Studio, não feito pela Roblox: você descreve a mudança em um chat na web, e o plugin dele para o Studio cria os scripts no seu Explorer, então não há código para colar.
Adicione correr com Shift com uma barra de stamina: velocidade de andar mais 10 enquanto o Shift estiver apertado, 100 de stamina gastando 20 por segundo, enchendo 15 por segundo depois de um segundo de descanso, um botão Sprint no celular, Q para dar dash, e um pulo duplo.
- Pode ler o seu place antes com Search Scripts e Read Script, para achar outros scripts que mudam o WalkSpeed (como um bônus de game pass) e a corrida somar a eles
- Escreve o ModuleScript, os LocalScripts e a checagem do servidor com Create Script
- É instruído a checar a compilação de cada script que escreve com Check Script, que compila o script no Studio sem rodá-lo
- Cria um ponto de desfazer antes e depois de cada lote de mudanças, então Ctrl+Z volta um lote de cada vez
O RoCode não consegue fazer uma animação de corrida: crie uma no Animation Editor e cole o ID dela. Com o plugin 3.9.11 ou mais recente, o RoCode pode testar o seu jogo no Studio e controlar um personagem de teste para conferir que funciona, e com o plugin 3.9.15 ou mais recente o personagem de teste pode apertar teclas, por exemplo segurar Shift e conferir que o WalkSpeed subiu. Ele decide quando rodar um teste, até 2 por build mais 1 para conferir a própria correção, e confere só o que escolheu testar, então teste a corrida, o dash e o pulo duplo você mesmo, e use o Device Simulator do Studio para os botões do celular. Movimento é um sistema entre muitos em um jogo; criar um jogo inteiro com o RoCode funciona com um sistema por prompt, como este. Como o RoCode se conecta ao Studio.
Perguntas frequentes
Por que meu script de correr não funciona no celular?
Um celular não tem tecla Shift. Ligue a corrida com ContextActionService:BindAction e passe true como terceiro argumento, o que adiciona um botão na tela em dispositivos de toque, como o ShiftToSprint e o MovementClient fazem.
A corrida deve ser feita no servidor?
Não. Cada dispositivo move o próprio personagem, então um WalkSpeed definido pelo servidor não segura um trapaceiro, que pode definir o dele, e a nova velocidade só chega depois de uma ida e volta, então a corrida começa atrasada. Corra no cliente e confira no servidor quanto os personagens andam de verdade, como no Passo 5. O beta de server authority da Roblox funciona de outro jeito e exige reescrever o código de movimento.
Por que meu personagem continua correndo depois que solto o Shift?
O script perdeu a soltura, normalmente porque só escuta o aperto. O ContextActionService manda End quando a tecla sobe, e Cancel quando outra ligação toma conta dela; o MovementClient para nos dois casos, e também quando a stamina acaba ou o personagem para de andar.
Como colocar animação de correr no Roblox?
Carregue uma animação de corrida com o Animator no Humanoid do personagem no mesmo LocalScript, toque quando a corrida começa e pare quando ela termina. Dê a ela a prioridade Movement. Animações começadas no seu próprio personagem aparecem para todo mundo.
Por que meu pulo duplo dispara sozinho no celular?
Segurar o botão de pulo do celular continua pedindo pulos. Só conte um pulo como novo depois que os pedidos param por um instante, como o script DoubleJump faz.
Qual é a velocidade padrão de andar no Roblox?
16 studs por segundo. Ela vem do StarterPlayer.CharacterWalkSpeed, que define o Humanoid.WalkSpeed de cada personagem novo. A corrida deste guia soma 10, então correr vai a 26.
Qual deve ser a velocidade da corrida no Roblox?
A maioria dos jogos soma entre metade e o total da velocidade de andar: 16 vira algo entre 24 e 32. Uma corrida curta e lenta combina com terror, e uma longa e rápida combina com mapas grandes. Os presets por tipo de jogo trazem velocidade de andar, bônus de corrida e números de stamina para cada um.
Como fazer uma corrida com stamina no Roblox?
Guarde um número de stamina no dispositivo do jogador, gaste a cada frame enquanto corre e encha de novo depois de um descanso curto, os dois escalados pelo tempo do frame, e pare a corrida quando chegar a 0. O MovementClient do Passo 3 faz isso com uma barra na tela; os números ficam no MovementConfig.
Como correr com controle no Roblox?
Ligue o ButtonL3 do controle (apertar o analógico esquerdo) com o ContextActionService junto com o Left Shift, como os dois scripts daqui fazem. O ShiftToSprint faz o L3 alternar, porque segurar o analógico apertado enquanto anda com ele cansa.
Correr com Shift conflita com o Shift Lock?
Pode conflitar. Jogadores que ligam o Shift Lock nas configurações do Roblox o alternam com a tecla Shift, então uma tecla faz duas coisas. A documentação da Roblox diz que as APIs de Shift Lock estão sendo deprecated. Se o conflito incomodar os seus jogadores, desligue o StarterPlayer.EnableMouseLockOption, ou ligue a corrida a outra tecla, como Left Ctrl, no MovementClient.
Fontes e leitura extra
- Roblox Creator Docs: ContextActionService (em inglês). BindAction, botões de toque, o limite de 7 botões e por que ele é melhor que o InputBegan na maioria dos casos
- Roblox Creator Docs: Humanoid (em inglês). WalkSpeed e a nota de segurança dele, MoveDirection, StateChanged e ChangeState com o exemplo de pulo duplo
- Roblox Creator Docs: LinearVelocity (em inglês). modo Plane, eixos tangentes e MaxForce
- Roblox Creator Docs: Mover constraints (em inglês). trocar o BodyVelocity deprecated pelo LinearVelocity
- Roblox Creator Docs: UserInputService (em inglês). JumpRequest e por que ele precisa de um debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (em inglês). o que um cliente controla, checagens de distância, leaky buckets e exceções para teleporte
- Roblox Creator Docs: Server authority model (em inglês). o modelo de movimento simulado pelo servidor, BindToSimulation e as configurações do Workspace que ele precisa
- Roblox Creator Docs: Input Action System (em inglês). o exemplo Character Sprint com InputAction e InputBinding
- Roblox Creator Docs: Custom abilities (em inglês). a habilidade de dash da Character Controller Library
- Roblox Creator Docs: Studio testing modes (em inglês). Device Simulator e Controller Emulator
Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 14 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.