Tutorial · Sistemas de juego

Cómo hacer correr con Shift en Roblox Studio (PC, celular y consola)

Correr con Shift en Roblox se reduce a un solo número, el WalkSpeed del Humanoid, que sube mientras mantienes Shift. El Paso 1 hace exactamente eso en un LocalScript corto que también funciona con un botón Sprint en el celular y con un mando. El resto de la guía añade lo que un juego más grande necesita alrededor: una barra de stamina, un dash hecho con la física actual, un doble salto que ignora un botón mantenido, y qué puede y qué no puede comprobar el servidor.

Actualizado el 14 de noviembre de 202629 min de lecturaEscrito por

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
  1. Cómo funciona
  2. 1. Correr con Shift
  3. 2. Módulo de ajustes
  4. 3. Correr y dash
  5. 4. Doble salto
  6. 5. Control del servidor
  7. 6. Pruébalo
  8. Valores de velocidad
  9. Scripts antiguos
  10. Input Action System
  11. Ampliarlo
  12. Errores comunes
  13. Con RoCode
  14. Preguntas frecuentes
  15. Fuentes y lecturas

Cómo funciona correr en Roblox

IlustraciónShift corre a WalkSpeed 26 mientras la barra baja, Q hace un dash por un cuarto de la barra, y una segunda pulsación de salto en el aire vuelve a saltar.

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.

Las piezas del sistema de movimiento
PiezaDónde vaQué hace
LocalScript ShiftToSprintStarterPlayerScriptsEl Paso 1 por sí solo: correr con teclado, celular y mando, sin stamina. MovementClient lo reemplaza cuando añades stamina y un dash.
ModuleScript MovementConfigReplicatedStorageLos números: bonus de carrera, stamina y dash. El LocalScript y el control del servidor lo leen los dos.
LocalScript MovementClientStarterPlayerScriptsEnlaza 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 DoubleJumpStarterCharacterScriptsDa un salto extra en el aire. Una copia nueva se ejecuta en cada personaje nuevo.
Script MovementCheckServerScriptServiceMide 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.
El Explorer cuando el sistema de movimiento está terminado
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.

  1. En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterPlayerScripts, haz clic en el botón + e inserta un LocalScript llamado ShiftToSprint.
  2. Reemplaza su contenido con el código de abajo y pulsa Play.
LocalScript en StarterPlayerScripts llamado ShiftToSprint
-- 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?

Cómo corre ShiftToSprint en cada dispositivo, con TOGGLE_ON_TOUCH_AND_GAMEPAD en true
Dispositivo y entradaFunciona comoPor qué
Teclado: Left ShiftMantenerMantener una tecla mientras te mueves es fácil, y al soltarla la carrera para al instante.
Mando: clic en el stick izquierdo (L3)AlternarMantener el stick hundido mientras diriges con él cansa.
Celular o tablet: el botón Sprint en pantallaAlternarUn 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.

  1. En el Explorer, pasa el mouse sobre ReplicatedStorage, haz clic en el botón + e inserta un ModuleScript.
  2. Cámbiale el nombre a MovementConfig y reemplaza su contenido con el código de abajo.
ModuleScript en ReplicatedStorage llamado MovementConfig
-- 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
Qué hace cada ajuste
AjusteValorEfecto
SPRINT_BONUS10Se suma a WalkSpeed mientras corres. El WalkSpeed por defecto de Roblox es 16, así que se corre a 26 studs por segundo.
MAX_STAMINA100Una barra llena.
DRAIN_PER_SECOND20Una barra llena dura 5 segundos de carrera.
REGEN_PER_SECOND15Una barra vacía tarda unos 6.7 segundos en llenarse.
REGEN_DELAY1Segundos de descanso antes de que empiece a llenarse.
MIN_TO_START20Stamina necesaria para empezar a correr.
DASH_SPEED60Studs por segundo durante un dash.
DASH_SECONDS0.2Cuánto dura un dash: unos 12 studs a 60 studs por segundo.
DASH_COST25Stamina que gasta cada dash.
DASH_COOLDOWN1Segundos 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.

  1. En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterPlayerScripts e inserta un LocalScript llamado MovementClient.
  2. Reemplaza su contenido con el código de abajo.
LocalScript en StarterPlayerScripts llamado MovementClient
-- 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.

  1. En el Explorer, despliega StarterPlayer, pasa el mouse sobre StarterCharacterScripts e inserta un LocalScript llamado DoubleJump.
  2. Reemplaza su contenido con el código de abajo.
LocalScript en StarterCharacterScripts llamado DoubleJump
-- 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.

  1. Pasa el mouse sobre ServerScriptService e inserta un Script llamado MovementCheck.
  2. Reemplaza su contenido con el código de abajo.
Script en ServerScriptService llamado MovementCheck
-- 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.

Qué atrapa el control, calculado a partir de sus números
Un tramposoQué hace MovementCheck
Pone WalkSpeed en 100Avisa en más o menos un segundo de correr
Pone WalkSpeed en 50Avisa 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 golpeAvisa en el siguiente control
Corre hasta 38 studs por segundo, más o menos una vez y media la velocidad de carreraNada: 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 infinitaNada: correr a 26 studs por segundo está permitido dure lo que dure
Vuela, salta sin límite o atraviesa paredesNada: 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:

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

  1. 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.
  2. 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.
  3. 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_SPEED o DASH_SECONDS en MovementConfig.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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í.
  9. 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.
  10. Si tu place tiene Workspace.PlayerScriptsUseInputActionSystem en Enabled, vuelve a probar el doble salto: la documentación de Roblox no dice si JumpRequest se 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.

Velocidad de caminar, carrera y stamina por tipo de juego. El tiempo de carrera es MAX_STAMINA / DRAIN_PER_SECOND; el relleno es MAX_STAMINA / REGEN_PER_SECOND más el REGEN_DELAY de 1 segundo
Tipo de juegoCharacterWalkSpeedSPRINT_BONUS (velocidad de carrera)DRAIN_PER_SECONDREGEN_PER_SECONDCarrera completaDe vacía a llenaDistancia con una barra
Esta guía1610 (26)20155 s7.7 s130 studs
Persecución de terror128 (20)25104 s11 s80 studs
Battlegrounds y combate1612 (28)15206.7 s6 sunos 187 studs
Mundo abierto o simulador1616 (32)102510 s5 s320 studs
Obby o parkour168 (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 suma SPRINT_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.

Patrones de tutoriales antiguos, y lo que hace esta guía en su lugar
PatrónPor qué es un problemaEsta guía
BodyVelocity para un dashObsoleto: Roblox dice que uses LinearVelocity en su lugarLinearVelocity en modo Plane
Un bucle en RunService.RenderSteppedReemplazado 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 vidaHeartbeat 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 desigualGasto y relleno escalados por deltaTime en cada frame
UserInputService.InputBegan sin comprobar el chatPulsar Shift mientras escribes un mensaje en el chat empieza a correrContextActionService, que además añade el botón del celular
Poner WalkSpeed = 16 al soltar o en cada framePisa cualquier otra velocidad, como un perk de game passCambia WalkSpeed solo cuando una carrera empieza o termina, sumando al valor actual
Correr mediante un RemoteEvent para que el servidor ponga WalkSpeedLos exploiters ponen su propio WalkSpeed de todos modos, y la carrera empieza con un viaje de ida y vuelta de retrasoCorrer en el cliente, más un control de distancia en el servidor
Un doble salto en cada JumpRequestJumpRequest se dispara varias veces por una petición de salto, y un botón mantenido puede seguir pidiendo saltosUna 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áctilContextActionService añade los botones en pantalla en dispositivos táctiles, sin una comprobación de dispositivo tuya
Humanoid:LoadAnimation para una animación de correrObsoleto en favor de Animator:LoadAnimationLa 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.

Tú escribes

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.

RoCode hace
  • 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

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.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.