Tutoriel · Systèmes de jeu

Comment faire un sprint avec Shift sur Roblox Studio (PC, mobile et console)

Sprinter avec Shift sur Roblox, ça se résume à un seul nombre, la WalkSpeed du Humanoid, qu'on augmente tant que Shift est maintenu. L'étape 1 fait exactement ça dans un court LocalScript qui marche aussi avec le bouton Sprint d'un téléphone et avec une manette. La suite du guide ajoute ce dont un plus gros jeu a besoin autour : une barre d'endurance (stamina), un dash basé sur la physique actuelle, un double saut qui ignore un bouton maintenu, et ce que le serveur peut vérifier ou non.

Mis à jour le 14 novembre 202630 min de lectureÉcrit par

En bref

Mets un seul LocalScript dans StarterPlayerScripts qui lie une action Sprint avec ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Tant que Shift est maintenu, ajoute 10 à Humanoid.WalkSpeed (16 devient 26) et remets la valeur quand tu relâches. Le true ajoute un bouton Sprint sur les écrans tactiles, et dans le script de ce guide ce bouton et le L3 de la manette activent et désactivent le sprint au lieu d'être maintenus.

  • Ajoute à la WalkSpeed actuelle au lieu de mettre 26, pour garder un bonus de vitesse venant d'un game pass.
  • Le sprint tourne sur l'appareil du joueur. Le serveur ne peut pas imposer une WalkSpeed ; il peut seulement mesurer la distance parcourue par les personnages et signaler les vitesses que le sprint n'explique pas.
  • Pour une barre d'endurance, un dash ou un double saut, les étapes 2 à 4 partent de la même idée. Pour la vitesse et la durée, les réglages par type de jeu donnent des chiffres pour l'horreur, le combat et le monde ouvert.
Sur cette page
  1. Fonctionnement
  2. 1. Sprint avec Shift
  3. 2. Module de réglages
  4. 3. Sprint et dash
  5. 4. Double saut
  6. 5. Vérification serveur
  7. 6. Tester
  8. Réglages de vitesse
  9. Anciens scripts
  10. Input Action System
  11. Aller plus loin
  12. Problèmes courants
  13. Avec RoCode
  14. Questions fréquentes
  15. Sources et lectures

Comment marche le sprint sur Roblox

Illustration animéeShift fait sprinter à une WalkSpeed de 26 pendant que la barre se vide, Q fait un dash pour un quart de la barre, et un deuxième appui sur saut en l'air fait sauter encore.

L'appareil de chaque joueur déplace le personnage de ce joueur. Le clavier, la manette ou l'écran tactile décide où va le personnage, et Roblox transmet le résultat au serveur et à tous les autres. Un sprint est donc un LocalScript qui augmente Humanoid.WalkSpeed tant qu'une touche est maintenue, et c'est tout ce que fait l'étape 1. Le reste de ce guide, c'est ce dont un plus gros jeu a besoin autour : une barre d'endurance, un dash, un double saut, et une vérification sur le serveur pour les joueurs qui trichent.

Les éléments du système de déplacement
ÉlémentOù il se trouveCe qu'il fait
Le LocalScript ShiftToSprintStarterPlayerScriptsL'étape 1 toute seule : sprint au clavier, sur téléphone et à la manette, sans endurance. MovementClient le remplace quand tu ajoutes l'endurance et un dash.
Le ModuleScript MovementConfigReplicatedStorageLes chiffres : bonus de sprint, endurance et dash. Le LocalScript et la vérification serveur le lisent tous les deux.
Le LocalScript MovementClientStarterPlayerScriptsLie Sprint et Dash à une touche, un bouton de manette et un bouton tactile, fait tourner la boucle d'endurance, dessine la barre et fait le dash.
Le LocalScript DoubleJumpStarterCharacterScriptsDonne un saut de plus en l'air. Une nouvelle copie tourne dans chaque nouveau personnage.
Le Script MovementCheckServerScriptServiceMesure la distance que chaque personnage parcourt vraiment et avertit dans Output quand quelqu'un va sans arrêt plus vite que ce que le sprint et le dash permettent.
L'Explorer une fois le système de déplacement terminé
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Si la différence entre Script et LocalScript est nouvelle pour toi, Script vs LocalScript vs ModuleScript (en anglais) explique où tourne chaque type et pourquoi.

Étape 1 : sprinter avec Shift dans un seul LocalScript

Si tout ce qu'il te faut, c'est courir plus vite tant que Shift est maintenu, ce seul script suffit. Il donne aussi aux téléphones un bouton Sprint à l'écran et permet à une manette de sprinter avec le stick gauche.

  1. Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts, clique sur le bouton + et insère un LocalScript nommé ShiftToSprint.
  2. Remplace son contenu par le code ci-dessous et appuie sur Play.
LocalScript dans StarterPlayerScripts nommé ShiftToSprint
-- LocalScript dans StarterPlayer > StarterPlayerScripts, nommé ShiftToSprint.
-- Maintiens Left Shift pour sprinter. À la manette, clique le stick gauche (L3) pour activer
-- et désactiver le sprint. Sur téléphone, touche le bouton Sprint pour l'activer et le désactiver.

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

-- Réglages
local SPRINT_BONUS = 10 -- ajouté à la WalkSpeed pendant le sprint (16 devient 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false : maintenir le bouton à la place

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- la WalkSpeed à retrouver

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
		-- Retenir la vitesse actuelle et y ajouter, pour garder un bonus de vitesse venant d'ailleurs
		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
		-- Maintenir : sprinter tant que la touche ou le bouton est enfoncé
		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
		-- Basculer : chaque appui active ou désactive le sprint
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Un seul appel lie la touche, le bouton de manette et, sur écran tactile, un bouton à l'écran
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- Un nouveau personnage commence en marchant : son Humanoid a déjà la WalkSpeed normale
player.CharacterAdded:Connect(function()
	sprinting = false
end)

Change SPRINT_BONUS pour un sprint plus rapide ou plus lent. Règle TOGGLE_ON_TOUCH_AND_GAMEPAD sur false pour que le bouton du téléphone et L3 marchent comme Shift : sprint seulement tant qu'ils sont maintenus.

BindAction lie une action à Left Shift et au bouton L3 de la manette, et son troisième argument, true, ajoute un bouton à l'écran sur les écrans tactiles ; SetTitle écrit "Sprint" dessus. Le gestionnaire reçoit aussi l'entrée, donc il peut distinguer un appui au clavier de la manette ou du bouton tactile. Quand le sprint commence, le script retient la WalkSpeed actuelle et ajoute SPRINT_BONUS ; quand il s'arrête, il remet la valeur retenue. Une vitesse réglée par un autre script, comme le bonus Speed du guide des game pass (en anglais), est conservée. Un nouveau personnage commence à sa WalkSpeed normale, donc le gestionnaire de CharacterAdded remet seulement l'indicateur à zéro.

Maintenir ou basculer ?

Comment ShiftToSprint fait sprinter sur chaque appareil, avec TOGGLE_ON_TOUCH_AND_GAMEPAD sur true
Appareil et entréeMarche en modePourquoi
Clavier : Left ShiftMaintenirMaintenir une touche en se déplaçant est facile, et relâcher arrête le sprint tout de suite.
Manette : cliquer le stick gauche (L3)BasculerGarder le stick enfoncé tout en dirigeant avec est fatigant.
Téléphone ou tablette : le bouton Sprint à l'écranBasculerUn pouce qui maintient le bouton ne peut pas appuyer sur Saut en même temps.

Pour le tester, appuie sur Play et maintiens Shift en marchant : tu accélères de 16 à 26 studs par seconde, et tu ralentis en relâchant. Pour un téléphone, choisis un téléphone dans le Device Simulator de Studio, appuie sur Play et touche Sprint une fois pour commencer et une fois pour arrêter. Pour une manette, ouvre le Controller Emulator pendant le test et clique L3. L'étape 6 a la liste de vérification complète pour chaque appareil.

Les étapes 2 et 3 remplacent ce script par un autre qui ajoute une barre d'endurance et un dash. Les étapes 4 et 5 ajoutent un double saut et une vérification serveur, et marchent avec l'un ou l'autre script.

Étape 2 : mettre les chiffres de l'endurance et du dash dans un module

Pour un sprint qui s'épuise, les étapes 2 et 3 remplacent ShiftToSprint par un LocalScript plus gros avec une barre d'endurance et un dash. Supprime d'abord ShiftToSprint : les deux lient l'action Sprint.

Tous les chiffres sont dans un seul ModuleScript, donc tu règles les sensations à un seul endroit. MovementClient les lit sur l'appareil de chaque joueur, et MovementCheck lit le même module sur le serveur pour savoir à quelle vitesse un sprint et un dash doivent aller.

  1. Dans l'Explorer, survole ReplicatedStorage, clique sur le bouton + et insère un ModuleScript.
  2. Renomme-le MovementConfig et remplace son contenu par le code ci-dessous.
ModuleScript dans ReplicatedStorage nommé MovementConfig
-- Un seul jeu de chiffres pour le LocalScript de déplacement et la vérification de vitesse du serveur.

local MovementConfig = {
	SPRINT_BONUS = 10, -- ajouté à la WalkSpeed actuelle : 16 (la valeur par défaut de Roblox) devient 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 secondes de sprint quand la barre est pleine
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- secondes après la fin du sprint avant que l'endurance revienne
	MIN_TO_START = 20, -- endurance nécessaire pour commencer un sprint, pour qu'une barre vide ne clignote pas

	DASH_SPEED = 60, -- studs par seconde pendant un dash
	DASH_SECONDS = 0.2, -- donc un dash parcourt environ 12 studs
	DASH_COST = 25, -- endurance
	DASH_COOLDOWN = 1,
}

return MovementConfig
Ce que fait chaque réglage
RéglageValeurEffet
SPRINT_BONUS10Ajouté à la WalkSpeed pendant le sprint. La WalkSpeed par défaut de Roblox est 16, donc un sprint va à 26 studs par seconde.
MAX_STAMINA100Une barre pleine.
DRAIN_PER_SECOND20Une barre pleine dure 5 secondes de sprint.
REGEN_PER_SECOND15Une barre vide met environ 6,7 secondes à se remplir.
REGEN_DELAY1Secondes de repos avant que le remplissage commence.
MIN_TO_START20Endurance nécessaire pour commencer un sprint.
DASH_SPEED60Studs par seconde pendant un dash.
DASH_SECONDS0,2Durée d'un dash : environ 12 studs à 60 studs par seconde.
DASH_COST25Endurance utilisée par chaque dash.
DASH_COOLDOWN1Secondes entre deux dashs.

Chaque côté fait tourner sa propre copie d'un module (un module tourne une fois par côté (en anglais)), donc un joueur qui modifie ces chiffres sur son appareil ne change que sa propre copie. Ça ne protège rien ici, cela dit : son appareil déplace déjà son personnage, donc il peut se donner une endurance infinie quoi que dise le module. La vérification serveur de l'étape 5 est construite en tenant compte de ça.

Étape 3 : sprint avec endurance, et dash

Ce LocalScript fait le travail que les joueurs ressentent. Il lie Sprint et Dash, dessine la barre d'endurance, fait tourner la boucle d'endurance à chaque image et fait le dash.

  1. Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts et insère un LocalScript nommé MovementClient.
  2. Remplace son contenu par le code ci-dessous.
LocalScript dans StarterPlayerScripts nommé MovementClient
-- Maintiens Shift (ou L3, ou le bouton Sprint sur téléphone) pour sprinter tant qu'il reste de l'endurance.
-- Appuie sur Q (ou B, ou le bouton Dash) pour faire un dash dans la direction où tu avances.

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 -- la WalkSpeed à retrouver quand le sprint s'arrête
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Barre d'endurance : un cadre avec un remplissage dont la largeur est l'endurance restante
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 : ici seulement un indicateur ; la boucle Heartbeat plus bas décide à chaque image s'il faut sprinter
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Seuls un appui ou un relâchement le changent : un doigt qui glisse sur le bouton tactile envoie 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()
	-- Pas de dash assis : un personnage assis est soudé à son siège, donc il pousserait tout le véhicule
	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 -- mettre le remplissage en pause, comme le sprint

	-- Dash dans la direction où le joueur avance, ou celle où il regarde s'il est immobile
	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 mode Plane tient la vitesse horizontale et laisse la gravité tranquille
	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

-- Un appel chacun lie une touche, un bouton de manette et, sur appareil tactile, un bouton à l'écran
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")

-- À chaque image : vider l'endurance pendant le sprint en mouvement, la remplir après un court repos
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

	-- Changer la WalkSpeed seulement quand le sprint commence ou s'arrête, pour qu'une vitesse réglée par
	-- un autre script (comme un pass de vitesse) soit gardée et que le sprint s'y ajoute
	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 nouveau personnage commence avec l'endurance pleine et rien de maintenu
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- le nouveau Humanoid commence à sa WalkSpeed normale
end)

La barre d'endurance est construite dans le code avec ResetOnSpawn sur false, donc elle reste à l'écran après une réapparition, et le gestionnaire de CharacterAdded tout en bas la remplit de nouveau pour chaque nouveau personnage. Les lignes type Config décrivent ce que renvoie le module, pour que la vérification stricte des types attrape un réglage mal orthographié ; elles ne changent rien quand le jeu tourne.

Clavier, manette et bouton de téléphone en un seul appel

ContextActionService:BindAction prend un nom d'action, une fonction de gestion, s'il faut créer un bouton tactile, puis les entrées. Passer true en troisième argument fait ajouter par ContextActionService un bouton à l'écran sur les appareils tactiles, dans un ScreenGui nommé ContextActionGui dans le PlayerGui du joueur. SetTitle écrit "Sprint" et "Dash" sur ces boutons. BindAction peut créer au plus 7 boutons tactiles, donc garde le compte si d'autres scripts de ton jeu en utilisent aussi.

Le gestionnaire reçoit l'état de l'entrée : Begin à l'appui et End au relâchement. onSprint retient seulement si Sprint est maintenu. Il traite aussi Cancel comme un relâchement, que ContextActionService envoie quand une autre liaison prend le contrôle de l'entrée, et il ignore Change, qu'un doigt qui bouge sur le bouton tactile peut envoyer. Les deux gestionnaires renvoient Pass, donc la liaison suivante sur la même touche reçoit quand même l'entrée.

La référence de ContextActionService de Roblox le recommande plutôt que UserInputService.InputBegan dans la plupart des cas. Son exemple est un klaxon de voiture sur H qui ne doit pas sonner pendant que le joueur écrit dans le chat : une liaison ne se déclenche que tant qu'elle est la plus récente pour cette entrée, donc quand la zone de chat prend le clavier, tu n'as rien à vérifier. Les entrées de la manette sont ButtonL3 (enfoncer le stick gauche, maintenu pendant que tu te déplaces) et ButtonB. L'exemple de sprint de Roblox lui-même utilise ButtonY, donc change le KeyCode dans BindAction si ça convient mieux à ton jeu.

La boucle d'endurance

RunService.Heartbeat se déclenche à chaque image après l'étape de physique et passe deltaTime, les secondes écoulées depuis l'image précédente. Multiplier les vitesses de vidage et de remplissage par cette valeur fait durer une barre pleine 5 secondes, que le jeu tourne à 30 ou à 240 images par seconde.

À chaque image, la boucle décide si le personnage doit sprinter : Sprint est maintenu, le personnage marche (Humanoid.MoveDirection est un vecteur nul sinon), et il reste de l'endurance. Commencer un sprint demande au moins MIN_TO_START (20) ; le continuer demande juste plus de 0. Sans cet écart, une barre vide qui se remplit d'un poil à chaque image allumerait et éteindrait le sprint à chaque image. Le remplissage commence REGEN_DELAY (1 seconde) après le dernier sprint ou dash, donc après avoir vidé la barre, un joueur attend environ 2,3 secondes avant de pouvoir sprinter de nouveau.

WalkSpeed ne change qu'à l'image où un sprint commence ou s'arrête. Au début, le script retient la WalkSpeed actuelle et ajoute SPRINT_BONUS ; à l'arrêt, il remet la valeur retenue. C'est pour ça qu'une vitesse réglée par un autre script survit : le bonus Speed du guide des game pass (en anglais) règle la WalkSpeed sur 24, et avec ce script ses détenteurs sprintent à 34. Un script qui écrit WalkSpeed = 16 à chaque image, ou à chaque relâchement, annulerait discrètement ce bonus.

Le dash

Le dash pousse le personnage dans la direction où il avance, ou celle où il regarde quand il est immobile, aplatie pour ne jamais pointer vers le haut ou le bas. Il coûte 25 d'endurance, met le remplissage en pause comme un sprint, et a un temps de recharge de 1 seconde. Rien dedans ne vérifie le sol, donc il marche aussi en l'air, ce qui va bien avec le double saut. Il ne fait rien quand le personnage est assis : un personnage assis est soudé à son siège, donc dans un véhicule la poussée pourrait pousser tout le véhicule.

La poussée est une contrainte LinearVelocity sur le RootAttachment de la part racine. En mode Plane avec les axes X et Z, elle tient la vitesse horizontale à 60 studs par seconde et laisse la direction verticale tranquille, donc la gravité continue d'agir et un dash depuis un rebord retombe normalement. MaxForce vaut math.huge, donc la poussée n'est pas limitée. Debris:AddItem détruit la contrainte après DASH_SECONDS sans faire attendre le script, donc le dash dure 0,2 seconde, environ 12 studs à cette vitesse.

Les anciens tutoriels utilisent BodyVelocity, que Roblox marque comme obsolète en conseillant d'utiliser LinearVelocity à la place. Son astuce qui consistait à mettre MaxForce à zéro sur un axe est remplacée par les modes Line, Plane et Vector de LinearVelocity. Comme l'appareil du joueur simule son propre personnage, la contrainte créée par le LocalScript le déplace, et les autres joueurs voient le dash comme n'importe quel autre mouvement.

Le propre tutoriel d'interface de Roblox attache une contrainte à humanoid.RootPart.RootAttachment de la même façon. Si ton jeu utilise un personnage personnalisé dont la part racine n'a pas d'Attachment nommé RootAttachment, le dash ne fait rien : ajoutes-en un au HumanoidRootPart de ton StarterCharacter.

Étape 4 : ajouter un double saut

Le double saut vit dans son propre LocalScript dans StarterCharacterScripts. Roblox met une copie des scripts de ce conteneur dans chaque personnage quand il apparaît, et ces copies ne survivent pas à une réapparition, donc chaque vie commence avec un script neuf et rien ne reste de la précédente.

  1. Dans l'Explorer, déplie StarterPlayer, survole StarterCharacterScripts et insère un LocalScript nommé DoubleJump.
  2. Remplace son contenu par le code ci-dessous.
LocalScript dans StarterCharacterScripts nommé DoubleJump
-- Donne un saut de plus en l'air. Il tourne de nouveau pour chaque nouveau personnage,
-- donc rien ne reste après une réapparition.

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 déclenche plusieurs fois pour un seul appui
local NEW_PRESS_GAP = 0.1 -- un bouton de saut maintenu continue de déclencher JumpRequest ; une pause aussi longue veut dire qu'il a été relâché

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 saut depuis le sol (pas un de nos sauts en l'air) recharge les sauts en l'air
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest se déclenche chaque fois que le joueur demande à sauter, par exemple avec Espace ou le bouton de saut du téléphone
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Seul un nouvel appui fait sauter de nouveau, donc maintenir le bouton ne gaspille pas le saut en l'air
	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)

Règle EXTRA_JUMPS sur 2 pour un triple saut.

Le script suit l'état du personnage avec Humanoid.StateChanged. Un passage à Jumping qui ne vient pas de Freefall est un saut depuis le sol, donc il donne le saut en l'air, et Landed le reprend. Marcher au-delà d'un rebord passe en Freefall sans saut, donc ça ne donne pas de saut en l'air. Si tu en veux un là aussi, règle aussi jumpsLeft quand l'état passe à Freefall depuis autre chose que Jumping.

UserInputService.JumpRequest se déclenche quand le joueur demande à sauter, par exemple avec Espace ou le bouton de saut d'un téléphone. La référence de Roblox prévient qu'il se déclenche plusieurs fois pour une seule demande de saut et recommande un anti-rebond, donc le script ignore les demandes dans les 0,25 seconde qui suivent le dernier saut. Maintenir le bouton de saut peut aussi continuer à demander des sauts, ce qui gaspillerait le saut en l'air dès que le personnage quitte le sol, donc une demande ne compte comme un nouvel appui qu'après 0,1 seconde sans aucune demande.

Le saut en l'air lui-même est Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). La référence de Roblox dit qu'il faut l'appeler depuis un LocalScript sur un appareil qui a la propriété réseau (network ownership) du personnage, c'est-à-dire par défaut l'appareil du joueur, pas le serveur. Son exemple de code pour ChangeState est un double saut.

Étape 5 : signaler les triches de vitesse sur le serveur

Les tutoriels de sprint s'arrêtent souvent au client. Un Script serveur ne peut pas faire confiance à la WalkSpeed d'un joueur, parce que les exploiteurs la changent sur leur propre appareil, mais il peut voir où leur personnage finit. MovementCheck le mesure deux fois par seconde et avertit dans Output quand quelqu'un va sans arrêt plus vite que ce que le sprint et le dash permettent. Il lit les chiffres du sprint et du dash dans MovementConfig, donc ajoute ce module de l'étape 2 même si tu as gardé ShiftToSprint.

  1. Survole ServerScriptService et insère un Script nommé MovementCheck.
  2. Remplace son contenu par le code ci-dessous.
Script dans ServerScriptService nommé MovementCheck
-- Les appareils des joueurs déplacent leurs propres personnages, donc un exploiteur peut régler n'importe quelle WalkSpeed.
-- Cette vérification mesure la distance que chaque personnage parcourt vraiment et avertit dans Output
-- quand quelqu'un va sans arrêt plus vite que ce que le sprint et le dash permettent. Elle ne fait qu'avertir :
-- le lag, les téléportations et les tapis roulants peuvent tous ressembler à un excès de vitesse, donc règle-la avant de punir qui que ce soit.

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 -- secondes
-- Vitesse de sprint plus une marge pour le lag. Augmente-la si tu vends des bonus de vitesse.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- de la marge pour un dash ou deux
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- à quelle vitesse les pointes passées sont pardonnées

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- la part racine sur laquelle lastPosition a été mesurée
local excess: { [Player]: number } = {} -- studs parcourus au-delà de la marge, pardonnés lentement

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
			-- Une réapparition est une nouvelle part racine, et une téléportation du serveur (début de manche, point de passage)
			-- règle l'attribut ci-dessous : recommencer à mesurer au lieu de signaler le saut
			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
				-- Seulement le mouvement horizontal : tomber vite, ce n'est pas tricher
				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

L'avertissement s'affiche dans Output dans Studio. Dans un jeu publié, il va dans le journal serveur de la Developer Console, que tu peux lire en tant que propriétaire du jeu : vois la sortie dans un jeu publié.

Ce qu'il mesure

Toutes les demi-secondes, le script lit la position de la part racine de chaque personnage et mesure de combien elle s'est déplacée sur le côté depuis la dernière vérification. La hauteur est ignorée, donc tomber ou sauter ne compte jamais ; les conseils de validation des déplacements de Roblox suggèrent la même projection sur le plan XZ pour les jeux qui se jouent au sol. La marge est la vitesse de marche par défaut plus le bonus de sprint, plus un quart pour le lag : 32,5 studs par seconde. La distance au-delà va dans un seau percé (leaky bucket), une sorte d'accumulateur qui, d'après la documentation de Roblox, marche bien pour les mouvements par à-coups selon beaucoup de développeurs. Le seau perd 3 studs à chaque vérification, et le script avertit quand il contient plus de 24 studs, ce qui laisse de la place pour environ deux dashs.

Ce que la vérification attrape, calculé à partir de ses chiffres
Un tricheur quiCe que fait MovementCheck
Règle la WalkSpeed sur 100Avertit en environ une seconde de course
Règle la WalkSpeed sur 50Avertit après environ 2,5 secondes de course
Enchaîne les dashs sans temps de recharge (60 studs par seconde)Avertit après environ 1,5 seconde
Se téléporte de plus d'environ 43 studs d'un coupAvertit à la vérification suivante
Court jusqu'à 38 studs par seconde, environ une fois et demie la vitesse de sprintRien : sous 38,5 studs par seconde, le seau se vide aussi vite qu'il se remplit
Modifie son propre MovementConfig pour une endurance infinieRien : un sprint à 26 studs par seconde est autorisé quelle que soit sa durée
Vole, saute sans limite ou traverse les mursRien : la vérification ignore la hauteur et ne regarde pas les collisions

La vérification attrape donc les triches grossières, celles qui rendent un joueur nettement plus rapide que tout le monde, et rate les triches prudentes. C'est la limite honnête d'une vérification de distance, et la raison pour laquelle Roblox construit quelque chose de plus solide (vois l'autorité serveur plus bas).

Pourquoi il ne fait qu'avertir

La documentation de Roblox souligne que les vérifications de vitesse simples peuvent signaler des joueurs innocents dont la connexion est instable, et qu'elles ne tiennent plus dans les jeux avec des véhicules ou d'autres déplacements complexes. Les pics de lag, les tapis roulants, les véhicules, les explosions qui projettent les personnages et tes propres téléportations peuvent tous ressembler à un excès de vitesse, donc le script affiche seulement un avertissement. Surveille Output pendant que toi et tes testeurs jouez normalement, augmente SPEED_ALLOWANCE si des joueurs honnêtes le déclenchent, et n'ajoute une punition, comme ramener le joueur en arrière, qu'une fois que la vérification reste silencieuse en jeu normal. Si des explosions projettent les personnages dans ton jeu, ignore aussi les joueurs dont le Humanoid n'a plus de vie.

Réapparitions et téléportations

Une réapparition crée une nouvelle part racine, et le script recommence à mesurer quand il en voit une, donc mourir loin du point d'apparition ne compte jamais comme un excès de vitesse. Les téléportations faites par tes propres scripts serveur ont besoin d'une exception, comme le dit la documentation de Roblox pour tout jeu avec des mécaniques de téléportation. Après la téléportation, ajoute player:SetAttribute("MovementCheckSkip", true), et la vérification suivante recommence à mesurer depuis la nouvelle position au lieu de signaler le saut :

Les pads et le menu du guide du téléporteur, et le pad Finish du guide du premier jeu, le règlent déjà après chaque déplacement.

Seule la valeur du serveur compte. Un attribut qu'un joueur règle sur son propre appareil reste sur cet appareil (vois ce qui est répliqué et ce qui ne l'est pas (en anglais)), donc un tricheur ne peut pas s'en servir pour désactiver la vérification.

La solution à long terme : l'autorité serveur

La documentation de sécurité de Roblox présente le modèle d'autorité serveur (server authority), en bêta au moment où ce guide est écrit, comme la façon la plus fiable d'arrêter les triches de déplacement. Le serveur devient la source de vérité et les appareils des joueurs ne font que transmettre leurs entrées, ce qui, d'après la documentation, empêche les speed hacks parce qu'on ne fait jamais confiance à un appareil pour donner sa propre position.

Passer à ce modèle, c'est une réécriture, pas un réglage. Avec lui, c'est le serveur qui fait tourner les déplacements, donc une WalkSpeed ou une LinearVelocity réglée seulement par un LocalScript est annulée quand l'état du serveur arrive. La documentation de Roblox dit que la logique principale doit tourner dans des fonctions RunService:BindToSimulation() dans un ModuleScript que le client et le serveur exécutent tous les deux. Le modèle demande aussi plusieurs réglages du Workspace, dont PlayerScriptsUseInputActionSystem, donc tes contrôles passeraient aussi à l'Input Action System. Garde la version de ce guide jusqu'à ce que tu déplaces le sprint, l'endurance et le dash dans cette configuration. D'ici là, une vérification de distance comme celle-ci est ce que décrit la section de Roblox sur la validation des déplacements.

Étape 6 : le tester sur chaque appareil

  1. Appuie sur Play et maintiens Shift en marchant. Tu accélères de 16 à 26 studs par seconde et la barre verte en bas de l'écran rétrécit. Après environ 5 secondes, elle est vide et tu reviens à la vitesse de marche.
  2. Relâche Shift. Après 1 seconde, la barre commence à se remplir. Tant qu'elle n'est pas pleine au cinquième, maintenir Shift ne fait rien.
  3. Appuie sur Q en marchant : tu files un peu vers l'avant et un quart de la barre disparaît. Rappuie tout de suite sur Q et rien ne se passe avant qu'une seconde soit passée. Si le dash te semble trop court ou trop long, change DASH_SPEED ou DASH_SECONDS dans MovementConfig.
  4. Saute, puis rappuie sur saut en l'air pour un deuxième saut. Atterris et recommence : chaque saut depuis le sol redonne le saut en l'air.
  5. Maintiens Espace pendant tout un saut. Tu dois avoir un saut, pas deux, parce que le saut en l'air demande un nouvel appui.
  6. Active le Device Simulator de Studio (en bêta au moment où ce guide est écrit : File, Beta Features, New Device Simulator, puis redémarre Studio), ou active l'ancien Device Emulator depuis le menu Test. Choisis un téléphone et appuie sur Play. Les boutons Sprint et Dash apparaissent. Maintiens Sprint en dirigeant, puis maintiens le bouton de saut pendant tout un saut et vérifie que tu n'as qu'un seul saut.
  7. Ouvre le Controller Emulator (Controller dans l'onglet Emulation, ou Virtual controller dans la barre d'outils du Device Simulator). Maintiens L3 en te déplaçant pour sprinter, appuie sur B pour un dash et deux fois sur A pour le double saut.
  8. Réinitialise ton personnage depuis le menu du jeu. La barre est de nouveau pleine, Output n'affiche aucun avertissement de MovementCheck et, si tu simules toujours un téléphone, les boutons Sprint et Dash sont toujours là.
  9. Maintenant, joue le tricheur. Clique sur le bouton Client/Server jusqu'à ce que l'Explorer montre le client, sélectionne le Humanoid de ton personnage sous Workspace et règle WalkSpeed sur 60 dans la fenêtre Properties. Marche quelques secondes : Output affiche un avertissement comme MovementCheck: YourName moved 60 studs/s. Remets 16, puis sprinte et fais des dashs normalement pendant une minute et vérifie qu'Output reste silencieux.
  10. Si ton jeu a Workspace.PlayerScriptsUseInputActionSystem réglé sur Enabled, reteste le double saut : la documentation de Roblox ne dit pas si JumpRequest se comporte pareil avec ce réglage.

Si rien ne se passe du tout, ouvre la fenêtre Output depuis le menu Window de Studio et cherche une erreur rouge venant de MovementClient, ou vois les problèmes courants.

Quelle vitesse et quelle durée : réglages par type de jeu

Le bon sprint dépend du jeu. Une course-poursuite d'horreur veut un sprint court et lent qui s'épuise au pire moment ; une grande carte ouverte en veut un long pour que les joueurs ne s'ennuient pas en la traversant. Ces réglages utilisent les mêmes scripts et ne changent que la vitesse de marche et MovementConfig. Ce sont nos points de départ, calculés à partir des réglages, pas mesurés sur des joueurs.

Vitesse de marche, sprint et endurance par type de jeu. La durée de sprint est MAX_STAMINA / DRAIN_PER_SECOND ; le remplissage est MAX_STAMINA / REGEN_PER_SECOND plus la seconde de REGEN_DELAY
Type de jeuCharacterWalkSpeedSPRINT_BONUS (vitesse de sprint)DRAIN_PER_SECONDREGEN_PER_SECONDSprint completDe vide à pleinDistance avec une barre
Ce guide1610 (26)20155 s7,7 s130 studs
Course-poursuite d'horreur128 (20)25104 s11 s80 studs
Battlegrounds et combat1612 (28)15206,7 s6 senviron 187 studs
Monde ouvert ou simulator1616 (32)102510 s5 s320 studs
Obby ou parkour168 (24)pas d'endurance : utilise ShiftToSprint
  • La vitesse de marche se règle dans StarterPlayer. Sélectionne StarterPlayer et règle CharacterWalkSpeed (16 par défaut). Chaque nouveau personnage commence à cette vitesse, le sprint y ajoute SPRINT_BONUS, et MovementCheck la lit aussi, donc la vérification serveur suit ton choix.
  • MovementCheck s'adapte. Il autorise la vitesse de marche plus le bonus de sprint, plus un quart pour le lag : 25 studs par seconde pour le réglage horreur, 40 pour le réglage monde ouvert. Il n'y a rien d'autre à changer.
  • Dans un obby, le sprint change le parcours. Courir plus vite permet de franchir des trous plus longs. Construis les sauts, puis teste chacun à la vitesse de sprint, sinon un sprint rend les niveaux trop faciles. Le guide des points de passage d'obby (en anglais) va bien avec ShiftToSprint.
  • Dans un jeu d'horreur, le tueur sert de référence. Rends le poursuivant un peu plus rapide que la vitesse de marche et un peu plus lent que le sprint, pour que la fuite dépende du moment où la barre se vide. Le guide du jeu d'horreur couvre le reste de la boucle de jeu.

Ce que les anciens scripts de sprint font mal

Les anciens tutoriels de sprint, de dash et de double saut marchent souvent encore, mais beaucoup utilisent des méthodes que Roblox a remplacées depuis, ou cassent d'autres systèmes de ton jeu. Si tu répares un script que tu as copié, compare-le à cette liste.

Méthodes des anciens tutoriels, et ce que fait ce guide à la place
MéthodePourquoi c'est un problèmeCe guide
BodyVelocity pour un dashObsolète : Roblox dit d'utiliser LinearVelocity à la placeLinearVelocity en mode Plane
Une boucle sur RunService.RenderSteppedRemplacé par PreRender pour le nouveau code. La logique de jeu comme l'endurance a sa place sur Heartbeat, que Roblox décrit pour les tâches périodiques comme la régénération de la vieHeartbeat avec deltaTime
Une boucle d'endurance construite sur wait()wait() est obsolète au profit de task.wait(), et il est limité, donc il peut attendre plus longtemps que demandé et un montant fixe par attente vide la barre de façon irrégulièreVidage et remplissage multipliés par deltaTime à chaque image
UserInputService.InputBegan sans vérifier le chatAppuyer sur Shift en écrivant un message dans le chat lance un sprintContextActionService, qui ajoute aussi le bouton du téléphone
Régler WalkSpeed = 16 au relâchement ou à chaque imageÉcrase toute autre vitesse, comme un bonus de game passChange la WalkSpeed seulement quand un sprint commence ou s'arrête, en ajoutant à la valeur actuelle
Sprinter par un RemoteEvent pour que le serveur règle la WalkSpeedLes exploiteurs règlent quand même leur propre WalkSpeed, et le sprint démarre avec un aller-retour de retardSprint côté client, plus une vérification de distance côté serveur
Un double saut à chaque JumpRequestJumpRequest se déclenche plusieurs fois pour une seule demande de saut, et un bouton maintenu peut continuer à demander des sautsUn écart de 0,25 seconde et une vérification de nouvel appui
UserInputService.TouchEnabled pour savoir "est-ce un mobile"Il vaut true sur les ordinateurs portables à écran tactileContextActionService ajoute les boutons à l'écran sur les appareils tactiles, sans vérification d'appareil de ta part
Humanoid:LoadAnimation pour une animation de courseObsolète au profit de Animator:LoadAnimationL'animation de course plus bas utilise l'Animator

La méthode plus récente de Roblox : l'Input Action System

La page de Roblox sur l'Input Action System prend un sprint de personnage comme premier exemple. Au lieu d'appels à BindAction, tu prépares les contrôles dans Studio : une InputAction nommée CharacterSprint dans un input context dans ReplicatedStorage, avec un InputBinding pour Left Shift, un pour le bouton Y de la manette et un relié à un bouton à l'écran que tu dessines dans StarterGui. Un script client écoute ensuite les événements Pressed et Released de l'action, double la WalkSpeed à l'appui et la remet au relâchement.

Ça vaut le coup de changer si tu veux disposer les contrôles dans Studio plutôt que dans le code, avoir ton propre bouton tactile au lieu de celui de ContextActionService, ou des contexts qui échangent des ensembles entiers de contrôles, comme un menu ou un véhicule. La page recommande aussi de régler Workspace.PlayerScriptsUseInputActionSystem sur Enabled, et l'autorité serveur l'exige.

La boucle d'endurance et le dash de ce guide marchent de la même façon avec l'Input Action System seul (sans autorité serveur). Garde MovementConfig, la boucle Heartbeat et dash(), supprime les deux appels à BindAction et leurs gestionnaires, et connecte les actions à la place : le Pressed de l'action de sprint met sprintHeld à true et son Released le met à false, et le Pressed de l'action de dash appelle dash(). Continue à chercher le Humanoid à chaque image comme le fait MovementClient, parce que l'exemple de la documentation garde le Humanoid du premier personnage, qui disparaît après une réapparition.

Roblox teste aussi une Character Controller Library, une bêta que tu actives dans les Beta Features et les Avatar Settings de Studio. Sa page sur les capacités personnalisées (custom abilities) construit un dash comme exemple, avec une fenêtre active de 0,2 seconde et un temps de recharge de 1 seconde, le même timing que le dash de ce guide.

Aller plus loin : animation, caméra et pass de sprint

Une animation de course

Crée une animation de course dans l'Animation Editor, règle sa priorité sur Movement (la priorité que Roblox recommande pour les animations de marche et de course), publie-la et copie son ID d'asset. Dans MovementClient, crée une Animation avec cet AnimationId, charge-la avec Animator:LoadAnimation en utilisant l'Animator dans le Humanoid du personnage, joue la piste là où un sprint commence et arrête-la là où le sprint s'arrête. Recharge-la pour chaque nouveau personnage.

Les animations que ton appareil lance sur ton propre personnage sont vues par tout le monde, à condition d'utiliser l'Animator que Roblox a placé là : les pistes chargées sur un Animator créé par un LocalScript ne sont pas répliquées. Humanoid:LoadAnimation, que beaucoup d'anciens tutoriels utilisent, est obsolète.

Élargir la caméra pendant le sprint

Un champ de vision un peu plus large donne l'impression d'un sprint plus rapide. Aux deux mêmes endroits, tweene workspace.CurrentCamera.FieldOfView de sa valeur par défaut de 70 à environ 80 quand un sprint commence, et reviens quand il s'arrête, par exemple avec TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox limite la valeur entre 1 et 120 et prévient que des valeurs très basses ou très hautes peuvent désorienter les joueurs. Si un autre script de ton jeu change aussi le champ de vision, reviens à la valeur que tu as trouvée plutôt qu'à 70.

Un sprint plus rapide en game pass

Le guide des game pass (en anglais) marche déjà avec ce script : son bonus Speed règle la WalkSpeed sur 24 sur le serveur pour chaque nouveau personnage, MovementClient ajoute le bonus de sprint par-dessus, et 34 studs par seconde restent dans ce que MovementCheck autorise.

Pour un pass qui rend le sprint lui-même plus rapide, ajoute un pass FastSprint aux PassConfig.ids de ce guide. Son script serveur règle alors l'attribut OwnsPass_FastSprint sur le joueur une fois le pass confirmé. Dans MovementClient, utilise un bonus plus grand que Config.SPRINT_BONUS quand player:GetAttribute("OwnsPass_FastSprint") == true. Dans MovementCheck, donne à ces joueurs une marge plus grande, en lisant le même attribut sur le serveur, où un joueur ne peut pas le changer, et vérifie que la nouvelle vitesse maximale reste sous ce que la vérification signale.

Une limite à connaître : si un autre script change la WalkSpeed en plein sprint, la fin de ce sprint remet la vitesse d'avant. La réapparition suivante remet la vitesse du pass, parce que le script des game pass l'applique à chaque nouveau personnage.

Problèmes courants

Ouvre la fenêtre Output (menu Window, puis Output) avant d'appuyer sur Play. La plupart des problèmes avec ces scripts y affichent une erreur ou un avertissement, avec le nom du script et la ligne.

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

MovementClient ou MovementCheck attend un module qui n'existe pas sous ce nom exact. Ce doit être un ModuleScript nommé MovementConfig directement dans ReplicatedStorage. Le guide des erreurs de script explique cet avertissement en détail.

Maintenir Shift ne fait rien

Vérifie que ShiftToSprint ou MovementClient est un LocalScript, pas un Script, et qu'il est dans StarterPlayerScripts. Avec MovementClient, un sprint demande aussi que le personnage marche et au moins 20 d'endurance pour commencer, donc maintiens Shift en te déplaçant. Si c'est le Shift Lock qui bascule à la place, vois la question sur le Shift Lock plus bas.

Le sprint s'arrête après quelques secondes

C'est l'endurance qui s'épuise : 100 d'endurance à 20 par seconde, ça dure 5 secondes. Augmente MAX_STAMINA ou baisse DRAIN_PER_SECOND dans MovementConfig.

Le dash ne fait rien

Un dash demande 25 d'endurance, attend 1 seconde après le précédent et ne fait rien quand tu es assis. Si ce n'est rien de tout ça, la part racine de ton personnage n'a peut-être pas d'Attachment nommé RootAttachment, ce qui arrive avec certains personnages personnalisés : ajoutes-en un au HumanoidRootPart de ton StarterCharacter.

Le double saut ne se fait jamais

DoubleJump doit être un LocalScript dans StarterCharacterScripts, pas dans StarterPlayerScripts, parce qu'il lit script.Parent comme étant le personnage. Appuie une deuxième fois sur saut après avoir quitté le sol : maintenir le bouton ne compte pas comme un nouvel appui, et marcher au-delà d'un rebord ne donne pas de saut en l'air.

Il n'y a pas de bouton Sprint ou Dash sur téléphone

ContextActionService n'ajoute ses boutons que sur les appareils tactiles, donc ils n'apparaissent jamais sur un PC sans écran tactile. Teste avec un téléphone dans le Device Simulator de Studio (une bêta : active New Device Simulator dans File, Beta Features, et redémarre Studio). BindAction peut créer au plus 7 boutons tactiles, donc compte combien d'autres scripts de ton jeu en créent.

MovementCheck avertit pour des joueurs honnêtes

Les causes habituelles sont une téléportation faite par un autre script serveur, un tapis roulant ou un véhicule, ou le lag. Règle l'attribut MovementCheckSkip après tes propres téléportations (vois Réapparitions et téléportations), et augmente SPEED_ALLOWANCE s'il se déclenche encore en jeu normal.

Un bonus de vitesse est perdu après un sprint

Un autre script a changé la WalkSpeed pendant le sprint, et le sprint s'est terminé en remettant la vitesse qu'il avait vue au début. Applique les bonus de vitesse quand le personnage apparaît, comme le fait le guide des game pass, pour qu'une réapparition remette la bonne vitesse.

Le faire avec RoCode

Si tu préfères ne pas tout mettre en place à la main, RoCode peut le construire dans le jeu que tu as ouvert. RoCode est un agent IA indépendant pour Roblox Studio, qui n'est pas fait par Roblox : tu décris le changement dans un chat web, et son plugin pour Studio crée les scripts dans ton Explorer, donc il n'y a pas de code à coller.

Tu écris

Ajoute un sprint avec Shift et une barre d'endurance : vitesse de marche plus 10 tant que Shift est maintenu, 100 d'endurance qui baisse de 20 par seconde et remonte de 15 par seconde après une seconde de repos, un bouton Sprint sur téléphone, Q pour un dash, et un double saut.

RoCode fait
  • Peut d'abord lire ton jeu avec Search Scripts et Read Script, pour trouver les autres scripts qui changent la WalkSpeed (comme un bonus de game pass) afin que le sprint s'y ajoute
  • Écrit le ModuleScript, les LocalScripts et la vérification serveur avec Create Script
  • A pour consigne de vérifier la compilation de chaque script qu'il écrit avec Check Script, qui le compile dans Studio sans le lancer
  • Place un point d'annulation avant et après chaque lot de changements, donc Ctrl+Z revient en arrière un lot à la fois

RoCode ne peut pas faire d'animation de course : crées-en une dans l'Animation Editor et colle son ID. Avec le plugin 3.9.11 ou plus récent, RoCode peut tester ton jeu dans Studio et contrôler un personnage de test pour vérifier que ça marche, et avec le plugin 3.9.15 ou plus récent le personnage de test peut appuyer sur des touches, par exemple maintenir Shift et vérifier que la WalkSpeed a augmenté. Il décide quand lancer un test, jusqu'à 2 par construction plus 1 pour vérifier sa propre correction, et ne vérifie que ce qu'il a choisi de tester, donc essaie toi-même le sprint, le dash et le double saut, et utilise le Device Simulator de Studio pour les boutons du téléphone. Le déplacement est un système parmi beaucoup d'autres dans un jeu ; construire un jeu entier avec RoCode se fait un système par demande, comme celle-ci. Comment RoCode se connecte à Studio.

Questions fréquentes

Pourquoi mon script de sprint ne marche pas sur mobile ?

Un téléphone n'a pas de touche Shift. Lie le sprint avec ContextActionService:BindAction et passe true en troisième argument, ce qui ajoute un bouton à l'écran sur les appareils tactiles, comme le font ShiftToSprint et MovementClient.

Faut-il faire le sprint sur le serveur ?

Non. Chaque appareil déplace son propre personnage, donc une WalkSpeed réglée par le serveur n'arrête pas un tricheur, qui peut régler la sienne, et la nouvelle vitesse n'arrive qu'après un aller-retour, donc le sprint démarre en retard. Fais le sprint côté client, et vérifie sur le serveur la distance que les personnages parcourent vraiment, comme à l'étape 5. La bêta d'autorité serveur de Roblox marche autrement et demande de réécrire le code de déplacement.

Pourquoi mon personnage continue de sprinter après avoir relâché Shift ?

Le script a raté le relâchement, en général parce qu'il n'écoute que l'appui. ContextActionService envoie End quand la touche remonte, et Cancel quand une autre liaison la prend ; MovementClient s'arrête dans les deux cas, et aussi quand l'endurance est vide ou que le personnage arrête de bouger.

Comment ajouter une animation de sprint ?

Charge une animation de course avec l'Animator du Humanoid du personnage dans le même LocalScript, joue-la quand le sprint commence et arrête-la quand il se termine. Donne-lui la priorité Movement. Les animations lancées sur ton propre personnage sont vues par tout le monde.

Pourquoi mon double saut se déclenche tout seul sur mobile ?

Maintenir le bouton de saut du téléphone continue de demander des sauts. Ne compte un saut comme nouveau qu'après une courte pause dans les demandes, comme le fait le script DoubleJump.

Quelle est la vitesse de marche par défaut sur Roblox ?

16 studs par seconde. Elle vient de StarterPlayer.CharacterWalkSpeed, qui règle la Humanoid.WalkSpeed de chaque nouveau personnage. Le sprint de ce guide ajoute 10, donc on sprinte à 26.

À quelle vitesse doit aller un sprint sur Roblox ?

La plupart des jeux ajoutent entre la moitié et la totalité de la vitesse de marche : 16 devient quelque chose entre 24 et 32. Un sprint court et lent va bien à l'horreur, et un sprint long et rapide aux grandes cartes. Les réglages par type de jeu donnent pour chacun la vitesse de marche, le bonus de sprint et les chiffres d'endurance.

Comment faire un sprint avec de l'endurance ?

Garde un nombre d'endurance sur l'appareil du joueur, vide-le à chaque image pendant le sprint et remplis-le après un court repos, les deux multipliés par la durée de l'image, et arrête le sprint quand il atteint 0. MovementClient à l'étape 3 fait ça avec une barre à l'écran ; les chiffres sont dans MovementConfig.

Comment sprinter avec une manette sur Roblox ?

Lie le ButtonL3 de la manette (enfoncer le stick gauche) avec ContextActionService en plus de Left Shift, comme le font les deux scripts ici. ShiftToSprint fait de L3 un bouton à bascule, parce que garder le stick enfoncé tout en dirigeant avec est fatigant.

Est-ce que le sprint avec Shift entre en conflit avec le Shift Lock ?

Ça peut arriver. Les joueurs qui activent le Shift Lock dans les paramètres de Roblox le basculent avec la touche Shift, donc une seule touche a deux rôles. La documentation de Roblox dit que les API du Shift Lock sont en train de devenir obsolètes. Si le conflit gêne tes joueurs, désactive StarterPlayer.EnableMouseLockOption, ou lie le sprint à une autre touche comme Left Ctrl dans MovementClient.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.