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
Comment marche le sprint sur Roblox
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.
| Élément | Où il se trouve | Ce qu'il fait |
|---|---|---|
Le LocalScript ShiftToSprint | StarterPlayerScripts | L'é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 MovementConfig | ReplicatedStorage | Les chiffres : bonus de sprint, endurance et dash. Le LocalScript et la vérification serveur le lisent tous les deux. |
Le LocalScript MovementClient | StarterPlayerScripts | Lie 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 DoubleJump | StarterCharacterScripts | Donne un saut de plus en l'air. Une nouvelle copie tourne dans chaque nouveau personnage. |
Le Script MovementCheck | ServerScriptService | 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. |
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.
- Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts, clique sur le bouton + et insère un LocalScript nommé
ShiftToSprint. - Remplace son contenu par le code ci-dessous et appuie sur Play.
-- 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 ?
| Appareil et entrée | Marche en mode | Pourquoi |
|---|---|---|
| Clavier : Left Shift | Maintenir | Maintenir 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) | Basculer | Garder le stick enfoncé tout en dirigeant avec est fatigant. |
| Téléphone ou tablette : le bouton Sprint à l'écran | Basculer | Un 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.
- Dans l'Explorer, survole ReplicatedStorage, clique sur le bouton + et insère un ModuleScript.
- Renomme-le
MovementConfiget remplace son contenu par le code ci-dessous.
-- 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
| Réglage | Valeur | Effet |
|---|---|---|
SPRINT_BONUS | 10 | Ajouté à la WalkSpeed pendant le sprint. La WalkSpeed par défaut de Roblox est 16, donc un sprint va à 26 studs par seconde. |
MAX_STAMINA | 100 | Une barre pleine. |
DRAIN_PER_SECOND | 20 | Une barre pleine dure 5 secondes de sprint. |
REGEN_PER_SECOND | 15 | Une barre vide met environ 6,7 secondes à se remplir. |
REGEN_DELAY | 1 | Secondes de repos avant que le remplissage commence. |
MIN_TO_START | 20 | Endurance nécessaire pour commencer un sprint. |
DASH_SPEED | 60 | Studs par seconde pendant un dash. |
DASH_SECONDS | 0,2 | Durée d'un dash : environ 12 studs à 60 studs par seconde. |
DASH_COST | 25 | Endurance utilisée par chaque dash. |
DASH_COOLDOWN | 1 | Secondes 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.
- Dans l'Explorer, déplie StarterPlayer, survole StarterPlayerScripts et insère un LocalScript nommé
MovementClient. - Remplace son contenu par le code ci-dessous.
-- 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.
- Dans l'Explorer, déplie StarterPlayer, survole StarterCharacterScripts et insère un LocalScript nommé
DoubleJump. - Remplace son contenu par le code ci-dessous.
-- 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.
- Survole ServerScriptService et insère un Script nommé
MovementCheck. - Remplace son contenu par le code ci-dessous.
-- 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.
| Un tricheur qui | Ce que fait MovementCheck |
|---|---|
| Règle la WalkSpeed sur 100 | Avertit en environ une seconde de course |
| Règle la WalkSpeed sur 50 | Avertit 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 coup | Avertit à la vérification suivante |
| Court jusqu'à 38 studs par seconde, environ une fois et demie la vitesse de sprint | Rien : sous 38,5 studs par seconde, le seau se vide aussi vite qu'il se remplit |
| Modifie son propre MovementConfig pour une endurance infinie | Rien : un sprint à 26 studs par seconde est autorisé quelle que soit sa durée |
| Vole, saute sans limite ou traverse les murs | Rien : 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 :
- Dans le système de manches, juste après
character:PivotTo(...)dansstartRound. - Dans le script des points de passage d'obby (en anglais), juste après chaque
character:PivotTo(...)qui envoie un joueur à son point de passage.
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
- 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.
- 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.
- 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_SPEEDouDASH_SECONDSdans MovementConfig. - 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.
- Maintiens Espace pendant tout un saut. Tu dois avoir un saut, pas deux, parce que le saut en l'air demande un nouvel appui.
- 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.
- 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.
- 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à.
- 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. - Si ton jeu a
Workspace.PlayerScriptsUseInputActionSystemréglé sur Enabled, reteste le double saut : la documentation de Roblox ne dit pas siJumpRequestse 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.
| Type de jeu | CharacterWalkSpeed | SPRINT_BONUS (vitesse de sprint) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Sprint complet | De vide à plein | Distance avec une barre |
|---|---|---|---|---|---|---|---|
| Ce guide | 16 | 10 (26) | 20 | 15 | 5 s | 7,7 s | 130 studs |
| Course-poursuite d'horreur | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 studs |
| Battlegrounds et combat | 16 | 12 (28) | 15 | 20 | 6,7 s | 6 s | environ 187 studs |
| Monde ouvert ou simulator | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 studs |
| Obby ou parkour | 16 | 8 (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 ajouteSPRINT_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éthode | Pourquoi c'est un problème | Ce guide |
|---|---|---|
BodyVelocity pour un dash | Obsolète : Roblox dit d'utiliser LinearVelocity à la place | LinearVelocity en mode Plane |
Une boucle sur RunService.RenderStepped | Remplacé 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 vie | Heartbeat 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ère | Vidage et remplissage multipliés par deltaTime à chaque image |
UserInputService.InputBegan sans vérifier le chat | Appuyer sur Shift en écrivant un message dans le chat lance un sprint | ContextActionService, 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 pass | Change 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 WalkSpeed | Les exploiteurs règlent quand même leur propre WalkSpeed, et le sprint démarre avec un aller-retour de retard | Sprint côté client, plus une vérification de distance côté serveur |
Un double saut à chaque JumpRequest | JumpRequest se déclenche plusieurs fois pour une seule demande de saut, et un bouton maintenu peut continuer à demander des sauts | Un é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 tactile | ContextActionService ajoute les boutons à l'écran sur les appareils tactiles, sans vérification d'appareil de ta part |
Humanoid:LoadAnimation pour une animation de course | Obsolète au profit de Animator:LoadAnimation | L'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.
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.
- 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
- Roblox Creator Docs : ContextActionService (en anglais). BindAction, les boutons tactiles, la limite de 7 boutons et pourquoi il vaut mieux qu'InputBegan dans la plupart des cas
- Roblox Creator Docs : Humanoid (en anglais). WalkSpeed et sa note de sécurité, MoveDirection, StateChanged et ChangeState avec son exemple de double saut
- Roblox Creator Docs : LinearVelocity (en anglais). le mode Plane, les axes tangents et MaxForce
- Roblox Creator Docs : Mover constraints (en anglais). passer de BodyVelocity, obsolète, à LinearVelocity
- Roblox Creator Docs : UserInputService (en anglais). JumpRequest et pourquoi il a besoin d'un anti-rebond
- Roblox Creator Docs : Network ownership, movement validation, and physics (en anglais). ce que contrôle un client, les vérifications de distance, les leaky buckets et les exceptions pour les téléportations
- Roblox Creator Docs : Server authority model (en anglais). le modèle de déplacement simulé par le serveur, BindToSimulation et les réglages du Workspace dont il a besoin
- Roblox Creator Docs : Input Action System (en anglais). l'exemple Character Sprint avec InputAction et InputBinding
- Roblox Creator Docs : Custom abilities (en anglais). la capacité de dash de la Character Controller Library
- Roblox Creator Docs : Studio testing modes (en anglais). Device Simulator et Controller Emulator
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.