La respuesta corta
Pon un LocalScript en StarterPlayerScripts que enlace una acción Sprint con ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Mientras mantienes Shift, suma 10 a Humanoid.WalkSpeed (16 pasa a 26) y devuélvelo al soltar. El true añade un botón Sprint en pantallas táctiles, y en el script de esta guía ese botón y el L3 del mando activan y desactivan la carrera en vez de mantenerse.
- Suma al WalkSpeed actual en vez de poner 26, así se conserva un aumento de velocidad de un game pass.
- Correr se ejecuta en el dispositivo del jugador. El servidor no puede imponer un WalkSpeed; solo puede medir cuánto se mueven los personajes y marcar velocidades que correr no explica.
- Para una barra de stamina, un dash o un doble salto, los Pasos 2 a 4 parten de la misma idea. Para saber qué tan rápido y por cuánto tiempo, los valores por tipo de juego dan números para terror, combate y mundo abierto.
En esta página
Cómo funciona correr en Roblox
El dispositivo de cada jugador mueve el personaje de ese jugador. El teclado, el mando o la pantalla táctil decide adónde va el personaje, y Roblox pasa el resultado al servidor y a todos los demás. Así que correr es un LocalScript que sube Humanoid.WalkSpeed mientras se mantiene una tecla, y eso es todo lo que hace el Paso 1. El resto de esta guía es lo que un juego más grande necesita alrededor: una barra de stamina, un dash, un doble salto y un control en el servidor para los jugadores que hacen trampa.
| Pieza | Dónde va | Qué hace |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | El Paso 1 por sí solo: correr con teclado, celular y mando, sin stamina. MovementClient lo reemplaza cuando añades stamina y un dash. |
ModuleScript MovementConfig | ReplicatedStorage | Los números: bonus de carrera, stamina y dash. El LocalScript y el control del servidor lo leen los dos. |
LocalScript MovementClient | StarterPlayerScripts | Enlaza Sprint y Dash a una tecla, un botón del mando y un botón táctil, ejecuta el bucle de stamina, dibuja la barra y hace el dash. |
LocalScript DoubleJump | StarterCharacterScripts | Da un salto extra en el aire. Una copia nueva se ejecuta en cada personaje nuevo. |
Script MovementCheck | ServerScriptService | Mide cuánto se mueve de verdad cada personaje y avisa en Output cuando alguien sigue yendo más rápido de lo que permiten correr y el dash. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Si la diferencia entre Script y LocalScript es nueva para ti, Script vs LocalScript vs ModuleScript (en inglés) explica dónde se ejecuta cada tipo y por qué.
Paso 1: Correr con Shift en un solo LocalScript
Si solo necesitas correr más rápido mientras mantienes Shift, este script basta. También les da a los celulares un botón Sprint en pantalla y deja que un mando corra con el stick izquierdo.
- En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterPlayerScripts, haz clic en el botón + e inserta un LocalScript llamado
ShiftToSprint. - Reemplaza su contenido con el código de abajo y pulsa Play.
-- LocalScript en StarterPlayer > StarterPlayerScripts, llamado ShiftToSprint.
-- Mantén Left Shift para correr. En un mando, haz clic en el stick izquierdo (L3) para activar
-- y desactivar la carrera. En un celular, toca el botón Sprint para activarla y desactivarla.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Ajustes
local SPRINT_BONUS = 10 -- se suma a WalkSpeed mientras corres (16 pasa a 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: mantener el botón en su lugar
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- el WalkSpeed al que se vuelve
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
-- Recuerda la velocidad actual y suma a ella, así se conserva un aumento de velocidad de otro lado
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
-- Mantener: corre mientras la tecla o el botón está pulsado
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 pulsación activa o desactiva la carrera
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Una llamada enlaza la tecla, el botón del mando y, en pantallas táctiles, un botón en pantalla
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- Un personaje nuevo empieza caminando: su Humanoid ya tiene el WalkSpeed normal
player.CharacterAdded:Connect(function()
sprinting = false
end)
Cambia SPRINT_BONUS para correr más rápido o más lento. Pon TOGGLE_ON_TOUCH_AND_GAMEPAD en false para que el botón del celular y L3 funcionen como Shift: correr solo mientras se mantienen.
BindAction enlaza una acción a Left Shift y al botón L3 del mando, y su tercer argumento, true, añade un botón en pantalla en pantallas táctiles; SetTitle escribe "Sprint" en él. El manejador también recibe la entrada, así que distingue una pulsación del teclado del mando o del botón táctil. Cuando empiezas a correr, el script recuerda el WalkSpeed actual y suma SPRINT_BONUS; cuando paras, devuelve el valor recordado. Una velocidad puesta por otro script, como el perk Speed de la guía de game pass (en inglés), se conserva. Un personaje nuevo empieza con su WalkSpeed normal, así que el manejador de CharacterAdded solo borra la marca.
¿Mantener o alternar?
| Dispositivo y entrada | Funciona como | Por qué |
|---|---|---|
| Teclado: Left Shift | Mantener | Mantener una tecla mientras te mueves es fácil, y al soltarla la carrera para al instante. |
| Mando: clic en el stick izquierdo (L3) | Alternar | Mantener el stick hundido mientras diriges con él cansa. |
| Celular o tablet: el botón Sprint en pantalla | Alternar | Un pulgar que mantiene el botón no puede pulsar Jump al mismo tiempo. |
Para probarlo, pulsa Play y mantén Shift mientras caminas: aceleras de 16 a 26 studs por segundo, y al soltar vuelves a frenar. Para un celular, elige un teléfono en el Device Simulator de Studio, pulsa Play y toca Sprint una vez para empezar y otra para parar. Para un mando, abre el Controller Emulator durante la prueba y haz clic en L3. El Paso 6 tiene la lista completa de dispositivos.
Los Pasos 2 y 3 reemplazan este script por uno que añade una barra de stamina y un dash. Los Pasos 4 y 5 añaden un doble salto y un control en el servidor, y funcionan con cualquiera de los dos scripts.
Paso 2: Pon los números de stamina y dash en un módulo
Para una carrera que se agota, los Pasos 2 y 3 cambian ShiftToSprint por un LocalScript más grande con una barra de stamina y un dash. Borra ShiftToSprint primero: los dos enlazan la acción Sprint.
Todos los números viven en un ModuleScript, así ajustas la sensación en un solo lugar. MovementClient los lee en el dispositivo de cada jugador, y MovementCheck lee el mismo módulo en el servidor para saber qué tan rápidos deben ser correr y el dash.
- En el Explorer, pasa el mouse sobre ReplicatedStorage, haz clic en el botón + e inserta un ModuleScript.
- Cámbiale el nombre a
MovementConfigy reemplaza su contenido con el código de abajo.
-- Un solo juego de números para el LocalScript de movimiento y el control de velocidad del servidor.
local MovementConfig = {
SPRINT_BONUS = 10, -- se suma al WalkSpeed actual: 16 (el valor por defecto de Roblox) pasa a 26
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 segundos de carrera con la barra llena
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- segundos después de dejar de correr antes de que vuelva la stamina
MIN_TO_START = 20, -- stamina necesaria para empezar a correr, así una barra vacía no parpadea
DASH_SPEED = 60, -- studs por segundo durante un dash
DASH_SECONDS = 0.2, -- así un dash recorre unos 12 studs
DASH_COST = 25, -- stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Ajuste | Valor | Efecto |
|---|---|---|
SPRINT_BONUS | 10 | Se suma a WalkSpeed mientras corres. El WalkSpeed por defecto de Roblox es 16, así que se corre a 26 studs por segundo. |
MAX_STAMINA | 100 | Una barra llena. |
DRAIN_PER_SECOND | 20 | Una barra llena dura 5 segundos de carrera. |
REGEN_PER_SECOND | 15 | Una barra vacía tarda unos 6.7 segundos en llenarse. |
REGEN_DELAY | 1 | Segundos de descanso antes de que empiece a llenarse. |
MIN_TO_START | 20 | Stamina necesaria para empezar a correr. |
DASH_SPEED | 60 | Studs por segundo durante un dash. |
DASH_SECONDS | 0.2 | Cuánto dura un dash: unos 12 studs a 60 studs por segundo. |
DASH_COST | 25 | Stamina que gasta cada dash. |
DASH_COOLDOWN | 1 | Segundos entre dashes. |
Cada lado ejecuta su propia copia de un módulo (un módulo se ejecuta una vez por lado, en inglés), así que un jugador que edita estos números en su dispositivo cambia solo su propia copia. Aun así, eso aquí no protege nada: su dispositivo ya mueve su personaje, así que puede darse stamina infinita diga lo que diga el módulo. El control del servidor del Paso 5 está hecho teniendo eso en cuenta.
Paso 3: Correr con stamina y hacer dash
Este LocalScript hace el trabajo que sienten los jugadores. Enlaza Sprint y Dash, dibuja la barra de stamina, ejecuta el bucle de stamina en cada frame y hace el dash.
- En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterPlayerScripts e inserta un LocalScript llamado
MovementClient. - Reemplaza su contenido con el código de abajo.
-- Mantén Shift (o L3, o el botón Sprint en un celular) para correr mientras dure la stamina.
-- Pulsa Q (o B, o el botón Dash) para hacer un dash en la dirección en la que te mueves.
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 -- el WalkSpeed al que se vuelve cuando dejas de correr
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Barra de stamina: un frame con un relleno cuyo ancho es la stamina que queda
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: aquí solo es una marca; el bucle Heartbeat de abajo decide en cada frame si se corre
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Solo una pulsación o una suelta lo cambia: un dedo que se desliza en el botón táctil envía 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()
-- Sin dash al estar sentado: un personaje sentado está soldado a su asiento, así que empujaría todo el vehículo
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 el relleno, igual que correr
-- Dash hacia donde se mueve el jugador, o hacia donde mira si está quieto
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 en modo Plane mantiene la velocidad horizontal y no toca la gravedad
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 llamada enlaza una tecla, un botón del mando y, en dispositivos táctiles, un botón en pantalla
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")
-- En cada frame: gasta stamina mientras corres y te mueves, y la rellena tras un breve descanso
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
-- Cambia WalkSpeed solo cuando la carrera empieza o termina, así una velocidad puesta por
-- otro script (como un pase de velocidad) se conserva y correr suma a ella
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)
-- Un personaje nuevo empieza con la stamina llena y nada pulsado
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- el Humanoid nuevo empieza con su WalkSpeed normal
end)
La barra de stamina se construye en código con ResetOnSpawn en false, así se queda en pantalla tras reaparecer, y el manejador de CharacterAdded del final la vuelve a llenar para cada personaje nuevo. Las líneas de type Config describen lo que devuelve el módulo, así el chequeo de tipos estricto puede detectar un ajuste mal escrito; no cambian nada cuando el juego se ejecuta.
Teclado, mando y un botón en el celular con una sola llamada
ContextActionService:BindAction recibe un nombre de acción, una función manejadora, si debe crear un botón táctil y luego las entradas. Pasar true como tercer argumento hace que ContextActionService añada un botón en pantalla en dispositivos táctiles, dentro de un ScreenGui llamado ContextActionGui en el PlayerGui del jugador. SetTitle escribe "Sprint" y "Dash" en esos botones. BindAction puede crear como máximo 7 botones táctiles, así que lleva la cuenta si otros scripts de tu juego también los usan.
El manejador recibe el estado de la entrada: Begin al pulsar y End al soltar. onSprint solo registra si Sprint está pulsado. También trata Cancel como una suelta, que ContextActionService envía cuando otro enlace toma la entrada, e ignora Change, que puede enviar un dedo que se mueve sobre el botón táctil. Los dos manejadores devuelven Pass, así el siguiente enlace de la misma tecla sigue recibiendo la entrada.
La referencia de ContextActionService de Roblox lo recomienda por encima de UserInputService.InputBegan en la mayoría de los casos. Su ejemplo es una bocina de auto en la H que no debe sonar mientras el jugador escribe en el chat: un enlace solo se dispara mientras es el más reciente para esa entrada, así que cuando la caja del chat toma el teclado no tienes nada que comprobar. Las entradas del mando son ButtonL3 (hundir el stick izquierdo, mantenido mientras te mueves) y ButtonB. El propio ejemplo de carrera de Roblox usa ButtonY, así que cambia el KeyCode en BindAction si eso le queda mejor a tu juego.
El bucle de stamina
RunService.Heartbeat se dispara en cada frame después del paso de física y pasa deltaTime, los segundos desde el frame anterior. Multiplicar por él las tasas de gasto y relleno hace que una barra llena dure 5 segundos tanto si el juego va a 30 como a 240 frames por segundo.
En cada frame el bucle decide si el personaje debe estar corriendo: Sprint está pulsado, el personaje camina (Humanoid.MoveDirection es un vector cero cuando no camina) y queda stamina. Empezar a correr necesita al menos MIN_TO_START (20); seguir corriendo necesita cualquier cosa por encima de 0. Sin esa diferencia, una barra vacía que se rellena un poquito en cada frame encendería y apagaría la carrera en cada frame. El relleno empieza REGEN_DELAY (1 segundo) después de la última carrera o el último dash, así que tras vaciar la barra un jugador espera unos 2.3 segundos antes de poder volver a correr.
WalkSpeed cambia solo en el frame en que una carrera empieza o termina. Al empezar, el script recuerda el WalkSpeed actual y suma SPRINT_BONUS; al terminar, devuelve el valor recordado. Por eso sobrevive una velocidad puesta por otro script: el perk Speed de la guía de game pass (en inglés) pone WalkSpeed en 24, y con este script sus dueños corren a 34. Un script que escribe WalkSpeed = 16 en cada frame, o en cada suelta, anularía ese perk sin avisar.
El dash
El dash empuja al personaje hacia donde se mueve, o hacia donde mira cuando está quieto, aplanado para que nunca apunte arriba ni abajo. Cuesta 25 de stamina, pausa el relleno como lo hace correr y tiene un cooldown de 1 segundo. No comprueba el suelo, así que también funciona en el aire, y combina bien con el doble salto. No hace nada mientras el personaje está sentado: un personaje sentado está soldado a su asiento, así que en un vehículo el empujón podría mover todo el vehículo.
El empujón es una restricción LinearVelocity en el RootAttachment de la parte raíz. En modo Plane con los ejes X y Z mantiene la velocidad horizontal a 60 studs por segundo y deja en paz la dirección vertical, así que la gravedad sigue funcionando y un dash desde un borde cae normalmente. MaxForce es math.huge, así que el empujón no tiene límite. Debris:AddItem destruye la restricción después de DASH_SECONDS sin hacer esperar al script, así que el dash dura 0.2 segundos, unos 12 studs a esa velocidad.
Los tutoriales antiguos usan BodyVelocity, que Roblox marca como obsoleto con la nota de usar LinearVelocity en su lugar. Su truco de poner MaxForce en cero en un eje es lo que reemplazan los modos Line, Plane y Vector de LinearVelocity. Como el dispositivo del jugador simula su propio personaje, la restricción que crea el LocalScript lo mueve, y los demás jugadores ven el dash como cualquier otro movimiento.
El propio tutorial de UI de Roblox une una restricción a humanoid.RootPart.RootAttachment de la misma forma. Si tu juego usa un personaje personalizado cuya parte raíz no tiene un Attachment llamado RootAttachment, el dash no hace nada: añade uno a la HumanoidRootPart de tu StarterCharacter.
Paso 4: Añade un doble salto
El doble salto vive en su propio LocalScript en StarterCharacterScripts. Roblox pone una copia de los scripts de ese contenedor en cada personaje cuando aparece, y esas copias no sobreviven a una reaparición, así que cada vida empieza con un script nuevo y nada pasa de la anterior.
- En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterCharacterScripts e inserta un LocalScript llamado
DoubleJump. - Reemplaza su contenido con el código de abajo.
-- Da un salto extra en el aire. Se vuelve a ejecutar para cada personaje nuevo,
-- así que nada pasa de una vida a otra después de reaparecer.
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 se dispara varias veces por una pulsación
local NEW_PRESS_GAP = 0.1 -- un botón de salto mantenido sigue disparando JumpRequest; una pausa así de larga significa que se soltó
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
-- Un salto desde el suelo (no uno de nuestros saltos en el aire) recarga los saltos en el aire
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- JumpRequest se dispara cada vez que el jugador pide saltar, como con Espacio o el botón de salto del celular
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Solo una pulsación nueva vuelve a saltar, así mantener el botón no gasta el salto en el aire
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)
Pon EXTRA_JUMPS en 2 para un triple salto.
El script sigue el estado del personaje con Humanoid.StateChanged. Un cambio a Jumping que no viene de Freefall es un salto desde el suelo, así que da el salto en el aire, y Landed lo quita otra vez. Caminar fuera de un borde pasa a Freefall sin salto, así que no da salto en el aire. Si quieres uno ahí también, pon jumpsLeft también cuando el estado cambie a Freefall desde cualquier cosa que no sea Jumping.
UserInputService.JumpRequest se dispara cuando el jugador pide saltar, por ejemplo con Espacio o el botón de salto de un celular. La referencia de Roblox avisa que se dispara varias veces por una sola petición de salto y recomienda un debounce, así que el script ignora las peticiones dentro de 0.25 segundos del último salto. Mantener el botón de salto también puede seguir pidiendo saltos, lo que gastaría el salto en el aire en cuanto el personaje deja el suelo, así que una petición solo cuenta como pulsación nueva tras 0.1 segundos sin ninguna.
El salto en el aire en sí es Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). La referencia de Roblox dice que hay que llamarlo desde un LocalScript en un dispositivo que tenga la propiedad de red (network ownership) del personaje, que por defecto es el dispositivo del propio jugador, no el servidor. Su ejemplo de código para ChangeState es un doble salto.
Paso 5: Detecta exploits de velocidad en el servidor
Los tutoriales de correr suelen quedarse en el cliente. Un Script del servidor no puede fiarse del WalkSpeed de un jugador, porque los exploiters lo cambian en su propio dispositivo, pero sí puede ver dónde termina su personaje. MovementCheck lo mide dos veces por segundo y avisa en Output cuando alguien sigue moviéndose más rápido de lo que permiten correr y el dash. Lee los números de carrera y dash de MovementConfig, así que añade ese módulo del Paso 2 aunque te hayas quedado con ShiftToSprint.
- Pasa el mouse sobre ServerScriptService e inserta un Script llamado
MovementCheck. - Reemplaza su contenido con el código de abajo.
-- Los dispositivos de los jugadores mueven sus propios personajes, así que un exploiter puede poner cualquier WalkSpeed.
-- Este control mide cuánto se mueve de verdad cada personaje y avisa en Output
-- cuando alguien sigue yendo más rápido de lo que permiten correr y el dash. Solo avisa:
-- el lag, los teletransportes y las cintas transportadoras pueden parecer exceso de velocidad, así que ajústalo antes de castigar a nadie.
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
-- Velocidad de carrera más margen para el lag. Súbelo si vendes aumentos de velocidad.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- margen para uno o dos dashes
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- qué tan rápido se perdonan los picos pasados
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- la parte raíz en la que se midió lastPosition
local excess: { [Player]: number } = {} -- studs movidos por encima del margen, perdonados poco a poco
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
-- Una reaparición es una parte raíz nueva, y un teletransporte del servidor (inicio de ronda, checkpoint)
-- pone el atributo de abajo: se vuelve a empezar a medir en vez de marcar el 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
-- Solo movimiento horizontal: caer rápido no es hacer trampa
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
El aviso aparece en Output de Studio. En un juego en vivo va al registro del servidor de la Developer Console, que puedes leer como dueño del juego: consulta la salida en un juego en vivo.
Qué mide
Cada medio segundo el script lee la posición de la parte raíz de cada personaje y mide cuánto se movió en horizontal desde el último control. La altura se ignora, así que caer o saltar nunca cuenta; los consejos de validación de movimiento de Roblox sugieren la misma proyección sobre el plano XZ para juegos con movimiento por el suelo. El margen es la velocidad de caminar por defecto más el bonus de carrera, más un cuarto por el lag: 32.5 studs por segundo. La distancia por encima de eso va a un leaky bucket (una cubeta que gotea), un tipo de acumulador que según la documentación de Roblox a muchos desarrolladores les funciona bien para movimientos en ráfaga. La cubeta pierde 3 studs en cada control, y el script avisa cuando tiene más de 24 studs, que es margen para unos dos dashes.
| Un tramposo | Qué hace MovementCheck |
|---|---|
| Pone WalkSpeed en 100 | Avisa en más o menos un segundo de correr |
| Pone WalkSpeed en 50 | Avisa tras unos 2.5 segundos de correr |
| Encadena dashes sin cooldown (60 studs por segundo) | Avisa tras unos 1.5 segundos |
| Se teletransporta más de unos 43 studs de golpe | Avisa en el siguiente control |
| Corre hasta 38 studs por segundo, más o menos una vez y media la velocidad de carrera | Nada: por debajo de 38.5 studs por segundo la cubeta se vacía tan rápido como se llena |
| Edita su propio MovementConfig para tener stamina infinita | Nada: correr a 26 studs por segundo está permitido dure lo que dure |
| Vuela, salta sin límite o atraviesa paredes | Nada: el control ignora la altura y no mira las colisiones |
Así que el control atrapa las trampas burdas, las que hacen a un jugador claramente más rápido que todos los demás, y se le escapan las cuidadosas. Ese es el límite honesto de un control de distancia, y la razón por la que Roblox está construyendo algo más fuerte (consulta server authority más abajo).
Por qué solo avisa
La documentación de Roblox señala que los controles de velocidad simples pueden marcar a jugadores inocentes con conexiones inestables y fallan en juegos con vehículos u otro movimiento complejo. Los picos de lag, las cintas transportadoras, los vehículos, las explosiones que lanzan personajes y tus propios teletransportes pueden parecer exceso de velocidad, así que el script solo imprime un aviso. Mira Output mientras tú y tus testers juegan normal, sube SPEED_ALLOWANCE si salta con jugadores honestos, y añade un castigo, como devolver al jugador atrás, solo cuando el control se quede callado en el juego normal. Si en tu juego las explosiones lanzan personajes, sáltate también a los jugadores cuyo Humanoid ya no tiene vida.
Reapariciones y teletransportes
Una reaparición crea una parte raíz nueva, y el script vuelve a empezar a medir cuando la ve, así que morir lejos del punto de aparición nunca cuenta como exceso de velocidad. Los teletransportes que hacen tus propios scripts del servidor necesitan una excepción, como dice la documentación de Roblox para cualquier juego con mecánicas de teletransporte. Después del teletransporte, añade player:SetAttribute("MovementCheckSkip", true), y el siguiente control empieza a medir desde la nueva posición en vez de marcar el salto:
- En el sistema de rondas, justo después de
character:PivotTo(...)enstartRound. - En el script de checkpoints del obby (en inglés), justo después de cada
character:PivotTo(...)que mueve a un jugador a su checkpoint.
Los pads y el menú de la guía del teletransportador, y el pad Finish de la guía del primer juego, ya lo ponen después de cada movimiento.
Solo cuenta el valor del servidor. Un atributo que un jugador pone en su propio dispositivo se queda en ese dispositivo (consulta qué se replica y qué no, en inglés), así que un tramposo no puede usarlo para apagar el control.
La solución a largo plazo: server authority
La documentación de seguridad de Roblox llama al modelo de server authority, en beta al momento de escribir esto, la forma más fiable de frenar los exploits de movimiento. El servidor pasa a ser la fuente de verdad y los dispositivos de los jugadores solo informan de sus entradas, lo que según la documentación evita los speed hacks porque nunca se confía en que un dispositivo informe su propia posición.
Cambiar es reescribir, no tocar un ajuste. Con ese modelo el servidor ejecuta el movimiento, así que un WalkSpeed o un LinearVelocity que solo pone un LocalScript se deshace cuando llega el estado del servidor. La documentación de Roblox dice que la lógica principal tiene que ejecutarse en funciones de RunService:BindToSimulation() dentro de un ModuleScript que ejecutan tanto el cliente como el servidor. El modelo también necesita varios ajustes de Workspace, entre ellos PlayerScriptsUseInputActionSystem, así que tus controles también pasarían al Input Action System. Quédate con la versión de esta guía hasta que pases la carrera, la stamina y el dash a esa configuración. Hasta entonces, un control de distancia como este es lo que describe la sección de validación de movimiento de Roblox.
Paso 6: Pruébalo en cada dispositivo
- Pulsa Play y mantén Shift mientras caminas. Aceleras de 16 a 26 studs por segundo y la barra verde de abajo de la pantalla se encoge. Después de unos 5 segundos está vacía y vuelves a la velocidad de caminar.
- Suelta Shift. Después de 1 segundo la barra empieza a llenarse otra vez. Hasta que esté llena en una quinta parte, mantener Shift no hace nada.
- Pulsa Q mientras caminas: sales disparado un poco hacia delante y desaparece un cuarto de la barra. Pulsa Q otra vez enseguida y no pasa nada hasta que pase un segundo. Si el dash se siente muy corto o muy largo, cambia
DASH_SPEEDoDASH_SECONDSen MovementConfig. - Salta y luego pulsa salto otra vez en el aire para un segundo salto. Aterriza y vuelve a probar: cada salto desde el suelo te devuelve el salto en el aire.
- Mantén Espacio pulsado durante todo un salto. Deberías tener un salto, no dos, porque el salto en el aire necesita una pulsación nueva.
- Activa el Device Simulator de Studio (en beta al momento de escribir esto: File, Beta Features, New Device Simulator, y luego reinicia Studio), o activa el antiguo Device Emulator desde el menú Test. Elige un teléfono y pulsa Play. Aparecen los botones Sprint y Dash. Mantén Sprint mientras diriges, luego mantén el botón de salto durante un salto y comprueba que solo tienes un salto.
- Abre el Controller Emulator (Controller en la pestaña Emulation, o Virtual controller en la barra del Device Simulator). Mantén L3 mientras te mueves para correr, pulsa B para el dash y pulsa A dos veces para el doble salto.
- Reinicia tu personaje desde el menú del juego. La barra vuelve a estar llena, Output no muestra ningún aviso de MovementCheck y, si sigues simulando un teléfono, los botones Sprint y Dash siguen ahí.
- Ahora haz de tramposo. Haz clic en el interruptor Client/Server hasta que el Explorer muestre el cliente, selecciona el Humanoid de tu personaje dentro de Workspace y pon WalkSpeed en 60 en la ventana Properties. Camina unos segundos: Output muestra un aviso como
MovementCheck: YourName moved 60 studs/s. Vuelve a ponerlo en 16, luego corre y haz dash normalmente durante un minuto y comprueba que Output se queda callado. - Si tu place tiene
Workspace.PlayerScriptsUseInputActionSystemen Enabled, vuelve a probar el doble salto: la documentación de Roblox no dice siJumpRequestse comporta igual con eso.
Si no pasa nada de nada, abre la ventana Output desde el menú Window de Studio y busca un error rojo de MovementClient, o consulta los errores comunes.
Qué tan rápido y por cuánto tiempo: valores por tipo de juego
La carrera correcta depende del juego. Una persecución de terror quiere una carrera corta y lenta que se acaba en el peor momento; un mapa abierto grande quiere una larga para que los jugadores no se aburran cruzándolo. Estos valores usan los mismos scripts y solo cambian la velocidad de caminar y MovementConfig. Son nuestros puntos de partida, calculados a partir de los ajustes, no medidos con jugadores.
| Tipo de juego | CharacterWalkSpeed | SPRINT_BONUS (velocidad de carrera) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Carrera completa | De vacía a llena | Distancia con una barra |
|---|---|---|---|---|---|---|---|
| Esta guía | 16 | 10 (26) | 20 | 15 | 5 s | 7.7 s | 130 studs |
| Persecución de terror | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 studs |
| Battlegrounds y combate | 16 | 12 (28) | 15 | 20 | 6.7 s | 6 s | unos 187 studs |
| Mundo abierto o simulador | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 studs |
| Obby o parkour | 16 | 8 (24) | sin stamina: usa ShiftToSprint |
- La velocidad de caminar vive en StarterPlayer. Selecciona StarterPlayer y pon
CharacterWalkSpeed(16 por defecto). Cada personaje nuevo empieza a esa velocidad, la carrera le sumaSPRINT_BONUS, y MovementCheck también la lee, así que el control del servidor sigue lo que elijas. - MovementCheck se adapta. Permite la velocidad de caminar más el bonus de carrera, más un cuarto por el lag: 25 studs por segundo con los valores de terror, 40 con los de mundo abierto. No hace falta cambiar nada más.
- En un obby, correr cambia el recorrido. Una carrera más rápida salta huecos más largos. Construye los saltos y luego prueba cada uno a velocidad de carrera, o correr hará triviales las etapas. La guía de checkpoints del obby (en inglés) va bien con ShiftToSprint.
- En un juego de terror, la referencia es el asesino. Haz al perseguidor un poco más rápido que la velocidad de caminar y un poco más lento que la carrera, así escapar depende de cuándo se acaba la barra. La guía del juego de terror cubre el resto del ciclo.
Qué hacen mal los scripts de correr antiguos
Los tutoriales antiguos de correr, dash y doble salto muchas veces todavía funcionan, pero muchos usan patrones que Roblox ya reemplazó, o rompen otros sistemas de tu juego. Si estás arreglando un script que copiaste, compáralo con esta lista.
| Patrón | Por qué es un problema | Esta guía |
|---|---|---|
BodyVelocity para un dash | Obsoleto: Roblox dice que uses LinearVelocity en su lugar | LinearVelocity en modo Plane |
Un bucle en RunService.RenderStepped | Reemplazado por PreRender para trabajo nuevo. La lógica del juego como la stamina va en Heartbeat, que Roblox describe para tareas periódicas como la regeneración de vida | Heartbeat con deltaTime |
Un bucle de stamina hecho con wait() | wait() está obsoleto en favor de task.wait(), y está limitado, así que puede esperar más de lo pedido y una cantidad fija por espera gasta de forma desigual | Gasto y relleno escalados por deltaTime en cada frame |
UserInputService.InputBegan sin comprobar el chat | Pulsar Shift mientras escribes un mensaje en el chat empieza a correr | ContextActionService, que además añade el botón del celular |
Poner WalkSpeed = 16 al soltar o en cada frame | Pisa cualquier otra velocidad, como un perk de game pass | Cambia WalkSpeed solo cuando una carrera empieza o termina, sumando al valor actual |
| Correr mediante un RemoteEvent para que el servidor ponga WalkSpeed | Los exploiters ponen su propio WalkSpeed de todos modos, y la carrera empieza con un viaje de ida y vuelta de retraso | Correr en el cliente, más un control de distancia en el servidor |
Un doble salto en cada JumpRequest | JumpRequest se dispara varias veces por una petición de salto, y un botón mantenido puede seguir pidiendo saltos | Una pausa de 0.25 segundos y una comprobación de pulsación nueva |
UserInputService.TouchEnabled como comprobación de "es celular" | Es true en laptops con pantalla táctil | ContextActionService añade los botones en pantalla en dispositivos táctiles, sin una comprobación de dispositivo tuya |
Humanoid:LoadAnimation para una animación de correr | Obsoleto en favor de Animator:LoadAnimation | La animación de correr de abajo usa el Animator |
La forma más nueva de Roblox: el Input Action System
La página del Input Action System de Roblox usa una carrera de personaje como primer ejemplo. En vez de llamadas a BindAction, configuras los controles en Studio: un InputAction llamado CharacterSprint dentro de un input context en ReplicatedStorage, con un InputBinding para Left Shift, otro para el botón Y del mando y otro unido a un botón en pantalla que diseñas en StarterGui. Luego un script del cliente escucha los eventos Pressed y Released de la acción, duplicando WalkSpeed al pulsar y devolviéndolo al soltar.
Vale la pena cambiar cuando quieres los controles organizados en Studio en vez de en código, tu propio botón táctil en lugar del de ContextActionService, o contextos que cambian conjuntos enteros de controles, como un menú o un vehículo. La página también recomienda poner Workspace.PlayerScriptsUseInputActionSystem en Enabled, y server authority lo exige.
El bucle de stamina y el dash de esta guía funcionan igual con el Input Action System por sí solo (sin server authority). Quédate con MovementConfig, el bucle Heartbeat y dash(), borra las dos llamadas a BindAction y sus manejadores, y conecta las acciones en su lugar: el Pressed de la acción de correr pone sprintHeld en true y su Released lo pone en false, y el Pressed de la acción de dash llama a dash(). Sigue buscando el Humanoid en cada frame como hace MovementClient, porque el ejemplo de la documentación guarda el Humanoid del primer personaje, que ya no existe tras reaparecer.
Roblox también está probando una Character Controller Library, una beta que activas en Beta Features y Avatar Settings de Studio. Su página de habilidades personalizadas construye un dash como ejemplo, con una ventana activa de 0.2 segundos y un cooldown de 1 segundo, los mismos tiempos que el dash de esta guía.
Cómo ampliarlo: animación, cámara y un pase de carrera
Una animación de correr
Haz una animación de correr en el Animation Editor, pon su prioridad en Movement (la prioridad que Roblox recomienda para animaciones de caminar y correr), publícala y copia su ID de asset. En MovementClient, crea un Animation con ese AnimationId, cárgalo con Animator:LoadAnimation usando el Animator que está dentro del Humanoid del personaje, reproduce el track donde empieza una carrera y detenlo donde termina. Vuelve a cargarlo para cada personaje nuevo.
Las animaciones que tu dispositivo inicia en tu propio personaje las ven todos, siempre que uses el Animator que Roblox puso ahí: los tracks cargados en un Animator que creó un LocalScript no se replican. Humanoid:LoadAnimation, que usan muchos tutoriales antiguos, está obsoleto.
Abre la cámara mientras corres
Un campo de visión un poco más amplio hace que correr se sienta más rápido. En los mismos dos lugares, haz tween de workspace.CurrentCamera.FieldOfView desde su valor por defecto de 70 a unos 80 cuando empieza una carrera y de vuelta cuando termina, por ejemplo con TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox limita el valor entre 1 y 120 y avisa que valores muy bajos o muy altos pueden desorientar a los jugadores. Si otro script de tu juego también cambia el campo de visión, vuelve al valor que encontraste en vez de a 70.
Una carrera más rápida como game pass
La guía de game pass (en inglés) ya funciona con este script: su perk Speed pone WalkSpeed en 24 en el servidor para cada personaje nuevo, MovementClient suma el bonus de carrera encima, y 34 studs por segundo queda dentro de lo que permite MovementCheck.
Para un pase que haga más rápida la propia carrera, añade un pase FastSprint a PassConfig.ids de esa guía. Su script del servidor pone entonces el atributo OwnsPass_FastSprint en el jugador cuando se confirma el pase. En MovementClient, usa un bonus más grande que Config.SPRINT_BONUS cuando player:GetAttribute("OwnsPass_FastSprint") == true. En MovementCheck, dales a esos jugadores un margen mayor, leyendo el mismo atributo en el servidor, donde un jugador no puede cambiarlo, y comprueba que la nueva velocidad máxima queda por debajo de lo que marca el control.
Un límite que conviene saber: si otro script cambia WalkSpeed en medio de una carrera, el final de esa carrera devuelve la velocidad de antes. La siguiente reaparición vuelve a poner la velocidad del pase, porque el script del game pass la aplica a cada personaje nuevo.
Errores comunes y soluciones
Abre la ventana Output (menú Window y luego Output) antes de pulsar Play. La mayoría de los problemas con estos scripts imprimen ahí un error o un aviso, con el nombre del script y la línea.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
MovementClient o MovementCheck está esperando un módulo que no está ahí con ese nombre exacto. Tiene que ser un ModuleScript llamado MovementConfig directamente dentro de ReplicatedStorage. La guía de errores de scripts explica este aviso en detalle.
Mantener Shift no hace nada
Comprueba que ShiftToSprint o MovementClient es un LocalScript, no un Script, y que está en StarterPlayerScripts. Con MovementClient, correr también necesita que el personaje esté caminando y al menos 20 de stamina para empezar, así que mantén Shift mientras te mueves. Si en vez de eso se activa Shift Lock, mira la pregunta sobre Shift Lock más abajo.
La carrera se corta después de unos segundos
Es la stamina que se acaba: 100 de stamina a 20 por segundo duran 5 segundos. Sube MAX_STAMINA o baja DRAIN_PER_SECOND en MovementConfig.
El dash no hace nada
Un dash necesita 25 de stamina, espera 1 segundo después del anterior y no hace nada mientras estás sentado. Si nada de eso es el problema, puede que la parte raíz de tu personaje no tenga un Attachment llamado RootAttachment, lo que pasa con algunos personajes personalizados: añade uno a la HumanoidRootPart de tu StarterCharacter.
El doble salto nunca pasa
DoubleJump tiene que ser un LocalScript en StarterCharacterScripts, no en StarterPlayerScripts, porque lee script.Parent como el personaje. Pulsa salto una segunda vez después de dejar el suelo: mantener el botón no cuenta como una pulsación nueva, y caminar fuera de un borde no da salto en el aire.
No hay botón Sprint ni Dash en el celular
ContextActionService solo añade sus botones en dispositivos táctiles, así que nunca aparecen en un PC sin pantalla táctil. Prueba con un teléfono en el Device Simulator de Studio (una beta: activa New Device Simulator en File, Beta Features, y reinicia Studio). BindAction puede crear como máximo 7 botones táctiles, así que cuenta cuántos crean otros scripts de tu juego.
MovementCheck avisa de jugadores honestos
Las causas habituales son un teletransporte hecho por otro script del servidor, una cinta transportadora o un vehículo, o el lag. Pon el atributo MovementCheckSkip después de tus propios teletransportes (consulta Reapariciones y teletransportes), y sube SPEED_ALLOWANCE si sigue saltando en el juego normal.
Se pierde un aumento de velocidad después de correr
Otro script cambió WalkSpeed durante la carrera, y la carrera terminó devolviendo la velocidad que vio al empezar. Aplica los aumentos de velocidad cuando aparece el personaje, como hace la guía de game pass, así una reaparición vuelve a poner la velocidad correcta.
Constrúyelo con RoCode
Si prefieres no montar todo esto a mano, RoCode puede construirlo en el place que tienes abierto. RoCode es un agente de IA independiente para Roblox Studio, no lo hace Roblox: describes el cambio en un chat web y su plugin de Studio crea los scripts en tu Explorer, así que no hay código que pegar.
Añade correr con Shift con una barra de stamina: velocidad de caminar más 10 mientras se mantiene Shift, 100 de stamina que bajan 20 por segundo y se rellenan 15 por segundo tras un segundo de descanso, un botón Sprint en celulares, Q para hacer dash y un doble salto.
- Puede leer tu place primero con Search Scripts y Read Script, para encontrar otros scripts que cambian WalkSpeed (como un perk de game pass) y que la carrera sume a ellos
- Escribe el ModuleScript, los LocalScripts y el control del servidor con Create Script
- Tiene la instrucción de comprobar que cada script que escribe compila con Check Script, que lo compila en Studio sin ejecutarlo
- Pone un punto de deshacer antes y después de cada lote de cambios, así que Ctrl+Z retrocede un lote cada vez
RoCode no puede hacer una animación de correr: créala en el Animation Editor y pega su ID. Con el plugin 3.9.11 o posterior, RoCode puede hacer una prueba de tu juego en Studio y controlar un personaje de prueba para comprobar que funciona, y con el plugin 3.9.15 o posterior el personaje de prueba puede pulsar teclas, por ejemplo mantener Shift y comprobar que WalkSpeed subió. Decide cuándo hacer una prueba, hasta 2 por build más 1 para comprobar su propio arreglo, y solo comprueba lo que eligió probar, así que prueba tú mismo la carrera, el dash y el doble salto, y usa el Device Simulator de Studio para los botones del celular. El movimiento es un sistema entre muchos en un juego; construir un juego entero con RoCode (en inglés) va un sistema por prompt como este. Cómo se conecta RoCode a Studio.
Preguntas frecuentes
¿Por qué mi script de correr no funciona en celular?
Un teléfono no tiene tecla Shift. Enlaza la carrera con ContextActionService:BindAction y pasa true como tercer argumento, que añade un botón en pantalla en dispositivos táctiles, como hacen ShiftToSprint y MovementClient.
¿Correr se debe hacer en el servidor?
No. Cada dispositivo mueve su propio personaje, así que un WalkSpeed puesto por el servidor no detiene a un tramposo, que puede poner el suyo, y la nueva velocidad solo llega después de un viaje de ida y vuelta, así que la carrera empieza tarde. Corre en el cliente y comprueba en el servidor cuánto se mueven de verdad los personajes, como en el Paso 5. La beta de server authority de Roblox funciona distinto y necesita reescribir el código de movimiento.
¿Por qué mi personaje sigue corriendo después de soltar Shift?
El script no vio la suelta, normalmente porque solo escucha la pulsación. ContextActionService envía End cuando la tecla sube, y Cancel cuando otro enlace la toma; MovementClient para con los dos, y también cuando se acaba la stamina o el personaje deja de moverse.
¿Cómo pongo una animación al correr?
Carga una animación de correr con el Animator del Humanoid del personaje en el mismo LocalScript, reprodúcela cuando empieza la carrera y detenla cuando termina. Dale la prioridad Movement. Las animaciones iniciadas en tu propio personaje las ven todos.
¿Por qué mi doble salto se activa solo en celular?
Mantener el botón de salto del celular sigue pidiendo saltos. Cuenta un salto como nuevo solo después de que las peticiones paren un momento, como hace el script DoubleJump.
¿Cuál es la velocidad de caminar por defecto en Roblox?
16 studs por segundo. Viene de StarterPlayer.CharacterWalkSpeed, que pone el Humanoid.WalkSpeed de cada personaje nuevo. La carrera de esta guía suma 10, así que se corre a 26.
¿Qué tan rápido debe ser correr en Roblox?
La mayoría de los juegos suman entre la mitad y el total de la velocidad de caminar: 16 pasa a algo entre 24 y 32. Una carrera corta y lenta va bien en terror y una larga y rápida en mapas grandes. Los valores por tipo de juego dan velocidad de caminar, bonus de carrera y números de stamina para cada uno.
¿Cómo hago correr con stamina en Roblox?
Guarda un número de stamina en el dispositivo del jugador, gástalo en cada frame mientras corre y rellénalo tras un breve descanso, los dos escalados por el tiempo del frame, y para la carrera cuando llegue a 0. MovementClient en el Paso 3 hace esto con una barra en pantalla; los números viven en MovementConfig.
¿Cómo corro con mando en Roblox?
Enlaza el ButtonL3 del mando (hundir el stick izquierdo) con ContextActionService junto a Left Shift, como hacen los dos scripts de aquí. ShiftToSprint hace de L3 un interruptor, porque mantener el stick hundido mientras diriges con él cansa.
¿Correr con Shift choca con Shift Lock?
Puede. Los jugadores que activan Shift Lock en los ajustes de Roblox lo alternan con la tecla Shift, así que una tecla hace dos cosas. La documentación de Roblox dice que las APIs de Shift Lock se están quedando obsoletas. Si el choque molesta a tus jugadores, desactiva StarterPlayer.EnableMouseLockOption, o enlaza la carrera a otra tecla como Left Ctrl en MovementClient.
Fuentes y lecturas
- Roblox Creator Docs: ContextActionService (en inglés). BindAction, botones táctiles, el límite de 7 botones y por qué supera a InputBegan en la mayoría de los casos
- Roblox Creator Docs: Humanoid (en inglés). WalkSpeed y su nota de seguridad, MoveDirection, StateChanged y ChangeState con su ejemplo de doble salto
- Roblox Creator Docs: LinearVelocity (en inglés). modo Plane, ejes tangentes y MaxForce
- Roblox Creator Docs: Mover constraints (en inglés). pasar del obsoleto BodyVelocity a LinearVelocity
- Roblox Creator Docs: UserInputService (en inglés). JumpRequest y por qué necesita un debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (en inglés). qué controla un cliente, controles de distancia, leaky buckets y excepciones para teletransportes
- Roblox Creator Docs: Server authority model (en inglés). el modelo de movimiento simulado en el servidor, BindToSimulation y los ajustes de Workspace que necesita
- Roblox Creator Docs: Input Action System (en inglés). el ejemplo Character Sprint con InputAction e InputBinding
- Roblox Creator Docs: Custom abilities (en inglés). la habilidad de dash de la Character Controller Library
- Roblox Creator Docs: Studio testing modes (en inglés). Device Simulator y Controller Emulator
Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 14 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.