In het kort
Zet één LocalScript in StarterPlayerScripts dat de actie Sprint koppelt met ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Tel zolang Shift ingedrukt is 10 op bij Humanoid.WalkSpeed (16 wordt 26), en zet bij het loslaten de vorige waarde terug. Het argument true voegt op touchscreens een knop Sprint toe, en in het script uit deze handleiding zetten die knop en L3 op een gamepad het rennen aan en uit, in plaats van te werken zolang je ze vasthoudt.
- Tel op bij de huidige WalkSpeed in plaats van 26 in te stellen, zodat een boost uit een gamepass blijft.
- Sprinten werkt op het apparaat van de speler. De server kan WalkSpeed niet afdwingen; hij kan alleen meten hoe ver personages bewegen en een snelheid melden die rennen niet verklaart.
- Een staminabalk, een dash en een dubbele sprong op hetzelfde idee voegen stap 2 tot en met 4 toe. Hoe snel en hoe lang je moet rennen, vertellen de presets per type game met getallen voor horror, gevechten en open wereld.
Op deze pagina
Hoe sprinten werkt in Roblox
Het apparaat van elke speler beweegt zijn eigen personage. Toetsenbord, controller of touchscreen bepalen waar het personage heen gaat, en Roblox stuurt het resultaat naar de server en naar alle anderen. Daarom is sprinten een LocalScript dat Humanoid.WalkSpeed verhoogt zolang een toets ingedrukt is, en dat is alles wat stap 1 doet. De rest van de handleiding is wat een grote game eromheen nodig heeft: een staminabalk, een dash, een dubbele sprong en een controle op de server tegen valsspelers.
| Onderdeel | Waar het staat | Wat het doet |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Stap 1 op zichzelf: rennen op toetsenbord, telefoon en gamepad, zonder stamina. Als je stamina en dash toevoegt, vervangt MovementClient het. |
ModuleScript MovementConfig | ReplicatedStorage | De getallen: sprintbonus, stamina en dash. Zowel het LocalScript als de controle op de server lezen ze. |
LocalScript MovementClient | StarterPlayerScripts | Koppelt Sprint en Dash aan een toets, een gamepadknop en een touchknop, draait de staminalus, tekent de balk en doet de dash. |
LocalScript DoubleJump | StarterCharacterScripts | Geeft één extra sprong in de lucht. In elk nieuw personage start een nieuwe kopie. |
Script MovementCheck | ServerScriptService | Meet hoe ver elk personage echt beweegt en schrijft een waarschuwing naar Output als iemand lange tijd sneller beweegt dan rennen en dash toelaten. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Is het verschil tussen Script en LocalScript nieuw voor je, dan legt Script, LocalScript en ModuleScript uit waar elk soort draait en waarom.
Stap 1: sprinten met Shift in één LocalScript
Wil je alleen sneller rennen zolang Shift ingedrukt is, dan is dit ene script genoeg. Het geeft telefoons ook een knop Sprint op het scherm, en op een gamepad kun je met de linkerstick rennen.
- Klap in de Explorer StarterPlayer open, ga met de muis over StarterPlayerScripts, klik op de knop + en voeg een LocalScript toe met de naam
ShiftToSprint. - Vervang de inhoud door de code hieronder en klik op Play.
-- LocalScript in StarterPlayer > StarterPlayerScripts met de naam ShiftToSprint.
-- Houd Left Shift ingedrukt om te rennen. Druk op een gamepad de linkerstick in (L3) om
-- rennen aan of uit te zetten. Tik op een telefoon op de knop Sprint om het aan of uit te zetten.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Instellingen
local SPRINT_BONUS = 10 -- komt bij WalkSpeed tijdens het rennen (16 wordt 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: de knop moet ingedrukt blijven
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- WalkSpeed om naar terug te gaan
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
-- Onthoud de huidige snelheid en tel erbij op, zodat een boost uit een ander script blijft
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
-- Vasthouden: rennen zolang de toets of knop ingedrukt is
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
-- Wisselen: elke druk zet rennen aan of uit
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Eén aanroep koppelt de toets, de gamepadknop en, op touchscreens, een knop op het scherm
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- Een nieuw personage begint lopend: zijn Humanoid heeft al de gewone WalkSpeed
player.CharacterAdded:Connect(function()
sprinting = false
end)
Verander SPRINT_BONUS om sneller of langzamer te rennen. Zet TOGGLE_ON_TOUCH_AND_GAMEPAD op false om de telefoonknop en L3 te laten werken zoals Shift: alleen rennen zolang je hem vasthoudt.
BindAction koppelt één actie aan Left Shift en aan de knop L3 op een gamepad, en het derde argument, true, voegt een knop toe op touchscreens; SetTitle zet daar "Sprint" op. De handler krijgt ook de invoer zelf, dus hij ziet het verschil tussen een druk op het toetsenbord en een gamepad of touchknop. Als het rennen begint, onthoudt het script de huidige WalkSpeed en telt het SPRINT_BONUS erbij op; als het stopt, zet het de onthouden waarde terug. Een snelheid die een ander script heeft ingesteld, zoals de Speed-perk uit de gamepass-handleiding, blijft behouden. Een nieuw personage begint met de gewone WalkSpeed, dus de handler CharacterAdded zet alleen de vlag terug.
Vasthouden of wisselen?
| Apparaat en invoer | Werkt als | Waarom |
|---|---|---|
| Toetsenbord: Left Shift | Vasthouden | Een toets vasthouden tijdens het bewegen is makkelijk, en loslaten stopt het rennen meteen. |
| Gamepad: linkerstick indrukken (L3) | Wisselen | De stick ingedrukt houden en er tegelijk mee sturen is vermoeiend. |
| Telefoon of tablet: knop Sprint op het scherm | Wisselen | Een duim die de knop vasthoudt, kan niet tegelijk op Jump drukken. |
Om te testen klik je op Play en houd je Shift ingedrukt tijdens het lopen: de snelheid stijgt van 16 naar 26 studs per seconde, en als je loslaat, ga je weer langzamer. Kies voor een telefoon een telefoon in de Device Simulator in Studio, klik op Play en tik één keer op Sprint om te beginnen en nog een keer om te stoppen. Open voor een gamepad de Controller Emulator tijdens een playtest en druk op L3. De volledige lijst met controles per apparaat staat in stap 6.
Stap 2 en 3 vervangen dit script door een ander, met een staminabalk en een dash. Stap 4 en 5 voegen een dubbele sprong en een controle op de server toe en werken met beide scripts.
Stap 2: de getallen voor stamina en dash in één module
Voor rennen dat opraakt, vervangen stap 2 en 3 ShiftToSprint door een groter LocalScript met een staminabalk en een dash. Verwijder eerst ShiftToSprint: beide scripts koppelen de actie Sprint.
Alle getallen staan in één ModuleScript, dus het gevoel van de beweging stel je op één plek af. MovementClient leest ze op het apparaat van elke speler, en MovementCheck leest dezelfde module op de server om te weten hoe snel rennen en de dash mogen zijn.
- Ga in de Explorer met de muis over ReplicatedStorage, klik op de knop + en voeg een ModuleScript toe.
- Hernoem het naar
MovementConfigen vervang de inhoud door de code hieronder.
-- Eén set getallen voor het beweging-LocalScript en de snelheidscontrole op de server.
local MovementConfig = {
SPRINT_BONUS = 10, -- komt bij de huidige WalkSpeed: 16 (de standaard van Roblox) wordt 26
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 seconden rennen met een volle balk
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- seconden na het rennen voordat de stamina zich begint te herstellen
MIN_TO_START = 20, -- stamina nodig om te beginnen met rennen, zodat een lege balk niet knippert
DASH_SPEED = 60, -- studs per seconde tijdens de dash
DASH_SECONDS = 0.2, -- zo legt de dash ongeveer 12 studs af
DASH_COST = 25, -- stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Instelling | Waarde | Effect |
|---|---|---|
SPRINT_BONUS | 10 | Komt bij WalkSpeed tijdens het rennen. De standaard-WalkSpeed in Roblox is 16, dus rennen gaat met 26 studs per seconde. |
MAX_STAMINA | 100 | Een volle balk. |
DRAIN_PER_SECOND | 20 | Een volle balk is genoeg voor 5 seconden rennen. |
REGEN_PER_SECOND | 15 | Een lege balk vult zich in ongeveer 6.7 seconden. |
REGEN_DELAY | 1 | Seconden rust voordat het herstel begint. |
MIN_TO_START | 20 | Stamina die nodig is om te beginnen met rennen. |
DASH_SPEED | 60 | Studs per seconde tijdens de dash. |
DASH_SECONDS | 0.2 | Hoe lang de dash duurt: ongeveer 12 studs bij 60 studs per seconde. |
DASH_COST | 25 | Stamina per dash. |
DASH_COOLDOWN | 1 | Seconden tussen dashes. |
Elke kant draait zijn eigen kopie van de module (een module draait één keer aan elke kant), dus een speler die deze getallen op zijn apparaat verandert, verandert alleen zijn eigen kopie. Maar hier beschermt dat niets: zijn apparaat beweegt zijn personage toch al, dus hij kan zichzelf eindeloze stamina geven, wat er ook in de module staat. De controle op de server uit stap 5 houdt daar rekening mee.
Stap 3: rennen met stamina en een dash
Dit LocalScript doet wat spelers voelen. Het koppelt Sprint en Dash, tekent de staminabalk, draait elk frame de staminalus en doet de dash.
- Klap in de Explorer StarterPlayer open, ga met de muis over StarterPlayerScripts en voeg een LocalScript toe met de naam
MovementClient. - Vervang de inhoud door de code hieronder.
-- Houd Shift ingedrukt (of L3, of de knop Sprint op een telefoon) om te rennen zolang er stamina is.
-- Druk op Q (of B, of de knop Dash) om een dash te maken in de bewegingsrichting.
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 -- WalkSpeed om naar terug te gaan als het rennen stopt
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Staminabalk: een frame met een vulling waarvan de breedte gelijk is aan de resterende stamina
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
-- Rennen: hier alleen een vlag; de Heartbeat-lus hieronder beslist elk frame of er gerend wordt
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Alleen indrukken en loslaten veranderen hem: een vinger die over de touchknop schuift, stuurt 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()
-- Geen dash als je zit: een zittend personage is aan de stoel gelast, dus hij zou het hele voertuig duwen
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 -- zet het herstel op pauze, zoals rennen dat doet
-- Dash in de richting waarin de speler beweegt, of waarin hij kijkt als hij stilstaat
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 in de modus Plane houdt de horizontale snelheid vast en laat de zwaartekracht met rust
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
-- Elke aanroep koppelt de toets, de gamepadknop en, op touchapparaten, een knop op het scherm
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")
-- Elk frame: verbruik stamina tijdens rennen en bewegen, herstel na een korte rust
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
-- Verander WalkSpeed alleen aan het begin en eind van het rennen, zodat een snelheid die
-- een ander script heeft ingesteld (bijvoorbeeld een speed pass) blijft en rennen erbij optelt
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)
-- Een nieuw personage begint met volle stamina en niets is ingedrukt
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- een nieuwe Humanoid begint met de gewone WalkSpeed
end)
De staminabalk wordt in code gemaakt met ResetOnSpawn op false, dus hij blijft na een respawn op het scherm, en de handler CharacterAdded onderaan vult hem opnieuw voor elk nieuw personage. De regels type Config beschrijven wat de module teruggeeft, zodat de strikte typecontrole een typfout in de naam van een instelling vangt; tijdens het spelen veranderen ze niets.
Toetsenbord, gamepad en telefoonknop met één aanroep
ContextActionService:BindAction krijgt de naam van de actie, een handlerfunctie, of er een touchknop gemaakt moet worden, en daarna de invoer. Geef je true als derde argument, dan voegt ContextActionService op touchapparaten een knop op het scherm toe, in een ScreenGui met de naam ContextActionGui in de PlayerGui van de speler. SetTitle zet "Sprint" en "Dash" op die knoppen. BindAction kan maximaal 7 touchknoppen maken, dus let op het aantal als andere scripts in de game ze ook gebruiken.
De handler krijgt de toestand van de invoer: Begin bij indrukken en End bij loslaten. onSprint onthoudt alleen of Sprint ingedrukt is. Hij telt ook Cancel als loslaten, dat ContextActionService stuurt als een andere koppeling de invoer overneemt, en negeert Change, dat een vinger kan sturen die over de touchknop beweegt. Beide handlers geven Pass terug, dus de volgende koppeling op dezelfde toets krijgt de invoer ook.
De referentie van Roblox over ContextActionService raadt hem in de meeste gevallen aan boven UserInputService.InputBegan. Het voorbeeld daar: een autotoeter op H die niet moet toeteren terwijl de speler in de chat typt. Een koppeling gaat alleen af zolang hij de laatste voor die invoer is, dus als de chat het toetsenbord overneemt, hoef je niets te controleren. De gamepadinvoer: ButtonL3 (de linkerstick indrukken, die je tijdens het bewegen vasthoudt) en ButtonB. Het eigen sprintvoorbeeld van Roblox gebruikt ButtonY, dus verander de KeyCode in BindAction als dat beter bij je game past.
De staminalus
RunService.Heartbeat gaat elk frame af na de physicsstap en geeft deltaTime door, het aantal seconden sinds het vorige frame. Vermenigvuldig je de snelheid van verbruik en herstel daarmee, dan is een volle balk genoeg voor 5 seconden, of de game nu op 30 of op 240 frames per seconde draait.
Elk frame beslist de lus of het personage moet rennen: Sprint is ingedrukt, het personage loopt (Humanoid.MoveDirection is de nulvector als hij stilstaat) en er is nog stamina. Om te beginnen met rennen is minstens MIN_TO_START (20) nodig; om door te gaan is alles boven 0 genoeg. Zonder die marge zou een lege balk die elk frame een beetje vult het rennen elk frame aan en uit zetten. Het herstel begint REGEN_DELAY (1 seconde) na het laatste rennen of de laatste dash, dus na een lege balk wacht een speler ongeveer 2.3 seconden voordat hij weer kan rennen.
WalkSpeed verandert alleen in het frame waarin het rennen begint of stopt. Bij het begin onthoudt het script de huidige WalkSpeed en telt het SPRINT_BONUS erbij op; aan het eind zet het de onthouden waarde terug. Daarom blijft een snelheid die een ander script instelt behouden: de Speed-perk uit de gamepass-handleiding zet WalkSpeed op 24, en met dit script rennen de eigenaren ervan op 34. Een script dat elk frame of bij elk loslaten WalkSpeed = 16 schrijft, zou die perk ongemerkt teniet doen.
De dash
De dash duwt het personage in de richting waarin hij beweegt, of waarin hij kijkt als hij stilstaat, en de richting wordt vlak gemaakt zodat hij nooit omhoog of omlaag wijst. Hij kost 25 stamina, zet het herstel op pauze zoals rennen, en heeft een cooldown van 1 seconde. Er wordt niet op de grond gecontroleerd, dus hij werkt ook in de lucht, wat goed samengaat met de dubbele sprong. Zolang het personage zit, doet de dash niets: een zittend personage is aan de stoel gelast, en in een voertuig zou de duw het hele voertuig kunnen verplaatsen.
De duw is een LinearVelocity-constraint op de RootAttachment van het root-part. In de modus Plane met de assen X en Z houdt hij een horizontale snelheid van 60 studs per seconde vast en laat hij de verticale richting met rust, dus de zwaartekracht werkt en een dash van een richel valt gewoon naar beneden. MaxForce is math.huge, dus de duw wordt door niets beperkt. Debris:AddItem vernietigt de constraint na DASH_SECONDS zonder het script te laten wachten, dus de dash duurt 0.2 seconde, ongeveer 12 studs op deze snelheid.
Oude tutorials gebruiken BodyVelocity, dat Roblox als verouderd heeft gemarkeerd met de opmerking om in plaats daarvan LinearVelocity te gebruiken. Zijn truc met een MaxForce van nul op één as wordt vervangen door de modi Line, Plane en Vector van LinearVelocity. Omdat het apparaat van de speler zijn eigen personage simuleert, beweegt een constraint die een LocalScript maakt hem, en andere spelers zien de dash zoals elke andere beweging.
De eigen UI-tutorial van Roblox hangt de constraint op precies dezelfde manier aan humanoid.RootPart.RootAttachment. Heeft je game een eigen personage waarvan het root-part geen Attachment met de naam RootAttachment heeft, dan doet de dash niets: voeg hem toe aan de HumanoidRootPart van je StarterCharacter.
Stap 4: dubbele sprong
De dubbele sprong zit in een eigen LocalScript in StarterCharacterScripts. Roblox zet bij het spawnen een kopie van de scripts uit deze container in elk personage, en die kopieën overleven een respawn niet, dus elk leven begint met een vers script en er wordt niets uit het vorige meegenomen.
- Klap in de Explorer StarterPlayer open, ga met de muis over StarterCharacterScripts en voeg een LocalScript toe met de naam
DoubleJump. - Vervang de inhoud door de code hieronder.
-- Geeft één extra sprong in de lucht. Start opnieuw voor elk nieuw personage,
-- dus na een respawn wordt er niets meegenomen.
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 gaat meerdere keren af per druk
local NEW_PRESS_GAP = 0.1 -- een ingedrukte springknop blijft JumpRequest sturen; een pauze van deze lengte betekent dat hij is losgelaten
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
-- Een sprong vanaf de grond (niet een van onze sprongen in de lucht) herstelt de sprongen in de lucht
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- JumpRequest gaat af als de speler om een sprong vraagt, bijvoorbeeld met Space of de springknop op een telefoon
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Alleen een nieuwe druk springt opnieuw, zodat een ingedrukte knop geen sprong in de lucht verspilt
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)
Zet EXTRA_JUMPS op 2 voor een driedubbele sprong.
Het script volgt de toestand van het personage via Humanoid.StateChanged. Een overgang naar Jumping die niet uit Freefall komt, is een sprong vanaf de grond, dus die geeft een sprong in de lucht, en Landed neemt hem weer af. Stap je van een richel af, dan komt het personage in Freefall zonder sprong, dus krijgt het geen sprong in de lucht. Wil je die daar ook, stel jumpsLeft dan ook in bij een overgang naar Freefall vanuit elke toestand behalve Jumping.
UserInputService.JumpRequest gaat af als de speler om een sprong vraagt, bijvoorbeeld met Space of de springknop op een telefoon. De referentie van Roblox waarschuwt dat hij meerdere keren afgaat per sprongverzoek en raadt een debounce aan, dus het script negeert verzoeken gedurende 0.25 seconde na de laatste sprong. Een ingedrukte springknop kan ook steeds sprongen blijven vragen en zou de sprong in de lucht verspillen op het moment dat het personage loskomt van de grond, dus een verzoek telt pas als nieuwe druk na 0.1 seconde zonder verzoeken.
De sprong in de lucht zelf is Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). De referentie van Roblox zegt dat je hem moet aanroepen vanuit een LocalScript op het apparaat dat het netwerkeigendom van het personage heeft, en standaard is dat het apparaat van de speler zelf, niet de server. Het codevoorbeeld bij ChangeState in de referentie is juist een dubbele sprong.
Stap 5: speedhacks vangen op de server
Sprinttutorials stoppen vaak bij de client. Een server-Script kan de WalkSpeed van een speler niet vertrouwen, want exploiters veranderen die op hun apparaat, maar hij ziet wel waar hun personage terechtkomt. MovementCheck meet dat twee keer per seconde en schrijft een waarschuwing naar Output als iemand lange tijd sneller beweegt dan rennen en dash toelaten. De getallen voor rennen en dash leest hij uit MovementConfig, dus voeg die module uit stap 2 toe, ook als je ShiftToSprint hebt gehouden.
- Ga met de muis over ServerScriptService en voeg een Script toe met de naam
MovementCheck. - Vervang de inhoud door de code hieronder.
-- De apparaten van spelers bewegen hun eigen personages, dus een exploiter kan elke WalkSpeed instellen.
-- Deze controle meet hoe ver elk personage echt beweegt en schrijft naar Output
-- als iemand lange tijd sneller beweegt dan rennen en dash toelaten. Ze waarschuwt alleen:
-- lag, teleports en lopende banden kunnen eruitzien als te hard gaan, dus stel haar af voordat je iemand straft.
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 -- seconden
-- Rensnelheid plus marge voor lag. Verhoog dit als je boosts verkoopt.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- marge voor een of twee dashes
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- hoe snel eerdere dashes worden vergeven
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- het root-part waarop lastPosition is gemeten
local excess: { [Player]: number } = {} -- studs boven de marge, worden geleidelijk vergeven
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
-- Een respawn is een nieuw root-part, en een teleport door de server (start van een ronde, checkpoint)
-- zet het attribuut hieronder: begin opnieuw met meten in plaats van een sprong te melden
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
-- Alleen horizontale beweging: snel vallen is geen valsspelen
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
De waarschuwing verschijnt in Output in Studio. In de live game komt hij in het serverlog van de Developer Console, dat je als eigenaar van de game kunt lezen: zie uitvoer in de live game.
Wat ze meet
Elke halve seconde leest het script de positie van het root-part van elk personage en meet het hoe ver dat horizontaal is verschoven sinds de vorige controle. Hoogte wordt genegeerd, dus vallen en springen tellen nooit mee; het advies van Roblox over bewegingscontrole stelt dezelfde projectie op het XZ-vlak voor in games waarin je over de grond loopt. De marge is de standaardloopsnelheid plus de sprintbonus en nog een kwart voor lag: 32.5 studs per seconde. Afstand daarboven gaat in een „lekkende emmer”, een buffer waarvan de documentatie van Roblox zegt dat hij voor veel ontwikkelaars goed werkt bij korte sprongen in snelheid. De emmer verliest 3 studs per controle, en het script waarschuwt als er meer dan 24 studs in zitten, een marge van ongeveer twee dashes.
| Valsspeler | Wat MovementCheck doet |
|---|---|
| Zet WalkSpeed op 100 | Waarschuwt na ongeveer een seconde rennen |
| Zet WalkSpeed op 50 | Waarschuwt na ongeveer 2.5 seconden rennen |
| Doet dashes achter elkaar zonder cooldown (60 studs per seconde) | Waarschuwt na ongeveer 1.5 seconde |
| Teleporteert meer dan 43 studs in één keer | Waarschuwt bij de volgende controle |
| Rent met een snelheid tot 38 studs per seconde, ongeveer anderhalf keer zo snel als rennen | Niets: onder 38.5 studs per seconde loopt de emmer even snel leeg als hij volloopt |
| Verandert zijn MovementConfig voor eindeloze stamina | Niets: rennen op 26 studs per seconde mag zo lang als je wilt |
| Vliegt, springt zonder grens of loopt door muren | Niets: de controle negeert hoogte en kijkt niet naar botsingen |
De controle vangt dus grove cheats waarbij een speler duidelijk sneller is dan alle anderen, en mist de voorzichtige. Dat is de eerlijke grens van een afstandscontrole en de reden dat Roblox iets sterkers maakt (zie server authority hieronder).
Waarom ze alleen waarschuwt
De documentatie van Roblox merkt op dat simpele snelheidscontroles eerlijke spelers met een instabiele verbinding kunnen melden en stukgaan in games met voertuigen of andere complexe beweging. Lagpieken, lopende banden, voertuigen, explosies die personages wegslingeren en je eigen teleports kunnen eruitzien als te hard gaan, dus het script print alleen een waarschuwing. Kijk in Output terwijl jij en je testers gewoon spelen, verhoog SPEED_ALLOWANCE als eerlijke spelers erop struikelen, en voeg pas een straf toe, zoals de speler terugzetten, als de controle stil blijft bij normaal spelen. Slingeren explosies in je game personages weg, sla dan ook spelers over van wie de Humanoid geen gezondheid meer heeft.
Respawns en teleports
Een respawn maakt een nieuw root-part, en het script begint opnieuw te meten als het dat ziet, dus doodgaan ver van het spawnpunt telt nooit als te hard gaan. Teleports die je eigen serverscripts doen, hebben een uitzondering nodig, zoals de documentatie van Roblox zegt voor elke game met teleports. Voeg na een teleport player:SetAttribute("MovementCheckSkip", true) toe, en de volgende controle begint te meten vanaf de nieuwe positie in plaats van een sprong te melden:
- In het rondesysteem direct na
character:PivotTo(...)instartRound. - In het checkpointscript voor een obby direct na elke
character:PivotTo(...)die de speler naar zijn checkpoint brengt.
De pads en menu's uit de teleporthandleiding en de Finish-pad uit de handleiding voor je eerste game zetten hem al na elke verplaatsing.
Alleen de waarde van de server telt. Een attribuut dat een speler op zijn apparaat zet, blijft op dat apparaat (zie wat wel en niet wordt gerepliceerd), dus een valsspeler kan de controle er niet mee uitzetten.
De oplossing voor later: server authority
De beveiligingsdocumentatie van Roblox noemt het model server authority, op het moment van schrijven in bèta, de betrouwbaarste manier om bewegingsexploits te stoppen. De server wordt de bron van waarheid en de apparaten van spelers melden alleen hun invoer, wat volgens de documentatie speedhacks laat mislukken, omdat een apparaat nooit wordt vertrouwd om zijn eigen positie te melden.
De overstap is herschrijven, geen afstellen. In dit model berekent de server de beweging, dus WalkSpeed of LinearVelocity die alleen een LocalScript instelt, wordt teruggedraaid als de toestand van de server binnenkomt. De documentatie van Roblox zegt dat de kernlogica moet draaien in functies van RunService:BindToSimulation() in een ModuleScript dat zowel de client als de server draait. Het model heeft ook een paar Workspace-instellingen nodig, waaronder PlayerScriptsUseInputActionSystem, dus je besturing verhuist ook naar het Input Action System. Houd de versie uit deze handleiding tot je rennen, stamina en dash naar die opzet hebt overgezet. Tot die tijd is een afstandscontrole zoals deze precies wat het deel van Roblox over bewegingscontrole beschrijft.
Stap 6: test op elk apparaat
- Klik op Play en houd Shift ingedrukt tijdens het lopen. De snelheid stijgt van 16 naar 26 studs per seconde, en de groene balk onder in het scherm wordt kleiner. Na ongeveer 5 seconden is hij leeg en loop je weer gewoon.
- Laat Shift los. Na 1 seconde begint de balk te vullen. Zolang hij nog geen vijfde vol is, doet Shift niets.
- Druk op Q tijdens het lopen: je schiet een stukje vooruit en een kwart van de balk is weg. Druk meteen nog eens op Q, en er gebeurt niets tot er een seconde voorbij is. Voelt de dash te kort of te lang, verander dan
DASH_SPEEDofDASH_SECONDSin MovementConfig. - Spring, en druk in de lucht nog eens op springen voor een tweede sprong. Land en probeer het opnieuw: elke sprong vanaf de grond geeft de sprong in de lucht terug.
- Houd Space de hele sprong ingedrukt. Je moet één sprong maken, niet twee, want de sprong in de lucht heeft een nieuwe druk nodig.
- Zet de Device Simulator in Studio aan (op het moment van schrijven een bèta: File, Beta Features, New Device Simulator, en herstart dan Studio) of zet de oude Device Emulator aan in het menu Test. Kies een telefoon en klik op Play. De knoppen Sprint en Dash verschijnen. Houd Sprint vast terwijl je stuurt, houd dan de springknop de hele sprong vast en controleer dat er maar één sprong is.
- Open de Controller Emulator (Controller op het tabblad Emulation of Virtual controller in het paneel van de Device Simulator). Houd L3 vast tijdens het bewegen om te rennen, druk op B voor een dash en twee keer op A voor een dubbele sprong.
- Reset je personage via het gamemenu. De balk is weer vol, er staat geen waarschuwing van MovementCheck in Output, en als je nog een telefoon simuleert, zijn de knoppen Sprint en Dash er nog.
- Speel nu de valsspeler. Klik op de schakelaar Client/Server tot de Explorer de client toont, selecteer de Humanoid van je personage in Workspace en zet WalkSpeed op 60 in het venster Properties. Loop een paar seconden rond: in Output verschijnt een waarschuwing zoals
MovementCheck: YourName moved 60 studs/s. Zet hem terug op 16, ren en dash dan een minuut zoals normaal en controleer dat Output stil blijft. - Staat
Workspace.PlayerScriptsUseInputActionSystemin je place op Enabled, test de dubbele sprong dan nog een keer: de documentatie van Roblox zegt niet ofJumpRequestzich daarmee hetzelfde gedraagt.
Gebeurt er helemaal niets, open dan het venster Output via het menu Window in Studio en zoek een rode fout van MovementClient, of kijk bij de veelvoorkomende fouten.
Hoe snel en hoe lang: presets per type game
Het juiste rennen hangt af van de game. Een achtervolging in een horrorgame wil kort, langzaam rennen dat op het slechtst mogelijke moment opraakt; een grote open map wil lang rennen, zodat spelers zich niet vervelen bij het oversteken. Deze presets gebruiken dezelfde scripts en veranderen alleen de loopsnelheid en MovementConfig. Het zijn onze startpunten, berekend uit de instellingen, niet gemeten bij spelers.
| Type game | CharacterWalkSpeed | SPRINT_BONUS (rensnelheid) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Volledig rennen | Van leeg tot vol | Afstand op één balk |
|---|---|---|---|---|---|---|---|
| Deze handleiding | 16 | 10 (26) | 20 | 15 | 5 s | 7.7 s | 130 studs |
| Achtervolging in horror | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 studs |
| Battlegrounds en gevechten | 16 | 12 (28) | 15 | 20 | 6.7 s | 6 s | ongeveer 187 studs |
| Open wereld of simulator | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 studs |
| Obby of parkour | 16 | 8 (24) | zonder stamina: gebruik ShiftToSprint |
- De loopsnelheid stel je in StarterPlayer in. Selecteer StarterPlayer en stel
CharacterWalkSpeedin (standaard 16). Elk nieuw personage begint met die snelheid, rennen telt erSPRINT_BONUSbij op, en MovementCheck leest hem ook, dus de controle op de server volgt jouw keuze. - MovementCheck past zich aan. Hij staat de loopsnelheid plus de sprintbonus en nog een kwart voor lag toe: 25 studs per seconde voor de horrorpreset, 40 voor de open wereld. Verder hoef je niets te veranderen.
- In een obby verandert rennen de baan. Met sneller rennen spring je over langere gaten. Bouw de sprongen en test dan elke sprong op rensnelheid, anders maakt rennen de stages te makkelijk. De handleiding over checkpoints voor een obby past goed bij ShiftToSprint.
- In horror is de moordenaar je maatstaf. Maak de achtervolger iets sneller dan de loopsnelheid en iets langzamer dan rennen, zodat ontsnappen afhangt van wanneer de balk opraakt. De handleiding voor een horrorgame behandelt de rest van de lus.
Wat er mis is met oude sprintscripts
Oude tutorials voor rennen, dash en dubbele sprong werken vaak nog, maar veel gebruiken trucs die Roblox sindsdien heeft vervangen, of maken andere systemen in je game kapot. Repareer je een gekopieerd script, vergelijk het dan met deze lijst.
| Truc | Wat het probleem is | Deze handleiding |
|---|---|---|
BodyVelocity voor een dash | Verouderd: Roblox zegt dat je in plaats daarvan LinearVelocity moet gebruiken | LinearVelocity in de modus Plane |
Een lus op RunService.RenderStepped | Voor nieuw werk is die vervangen door PreRender. Gamelogica zoals stamina hoort op Heartbeat, dat Roblox beschrijft voor terugkerende taken zoals het herstellen van gezondheid | Heartbeat met deltaTime |
Een staminalus op wait() | wait() is verouderd ten gunste van task.wait() en wordt afgeremd, dus hij kan langer wachten dan gevraagd, en een vast verbruik per wait verbruikt stamina ongelijkmatig | Verbruik en herstel elk frame met deltaTime |
UserInputService.InputBegan zonder chatcontrole | Een druk op Shift tijdens het typen van een chatbericht start het rennen | ContextActionService, dat ook een knop op de telefoon toevoegt |
WalkSpeed = 16 bij loslaten of elk frame | Overschrijft elke andere snelheid, zoals een gamepass-perk | Verandert WalkSpeed alleen aan het begin en eind van het rennen, en telt op bij de huidige waarde |
| Rennen via een RemoteEvent zodat de server WalkSpeed instelt | Exploiters stellen hun WalkSpeed toch zelf in, en het rennen begint met de vertraging van een heen-en-terugreis | Rennen op de client plus een afstandscontrole op de server |
Dubbele sprong bij elke JumpRequest | JumpRequest gaat meerdere keren af per sprongverzoek, en een ingedrukte knop kan sprongen blijven vragen | Een pauze van 0.25 seconde en een controle op een nieuwe druk |
UserInputService.TouchEnabled als controle „is dit een telefoon” | Hij is true op laptops met een touchscreen | ContextActionService voegt op touchapparaten knoppen op het scherm toe zonder je eigen apparaatcontrole |
Humanoid:LoadAnimation voor een renanimatie | Verouderd ten gunste van Animator:LoadAnimation | De renanimatie hieronder gebruikt de Animator |
De nieuwe manier van Roblox: het Input Action System
De pagina van Roblox over het Input Action System neemt sprinten met een personage als eerste voorbeeld. In plaats van BindAction-aanroepen stel je de besturing in Studio in: een InputAction met de naam CharacterSprint in een input context in ReplicatedStorage, met één InputBinding voor Left Shift, één voor de knop Y op een gamepad en één gekoppeld aan een knop op het scherm die je in StarterGui tekent. Een clientscript luistert dan naar de events Pressed en Released van de actie, verdubbelt WalkSpeed bij indrukken en zet hem terug bij loslaten.
Overstappen is de moeite waard als je de besturing in Studio wilt indelen in plaats van in code, een eigen touchknop wilt in plaats van de knop van ContextActionService, of contexts wilt die hele sets besturing wisselen, bijvoorbeeld voor menu's of voertuigen. De pagina raadt ook aan Workspace.PlayerScriptsUseInputActionSystem op Enabled te zetten, en server authority vereist dat.
De staminalus en de dash uit deze handleiding werken op dezelfde manier met alleen het Input Action System (zonder server authority). Houd MovementConfig, de Heartbeat-lus en dash(), verwijder de twee BindAction-aanroepen en hun handlers, en koppel in plaats daarvan de acties: Pressed van de sprintactie zet sprintHeld op true en zijn Released op false, en Pressed van de dashactie roept dash() aan. Blijf de Humanoid elk frame opzoeken zoals MovementClient doet, want het voorbeeld uit de documentatie bewaart de Humanoid van het eerste personage, en na een respawn bestaat die niet meer.
Roblox test ook de Character Controller Library, een bèta die je aanzet in Beta Features en Avatar Settings in Studio. Zijn pagina over eigen vaardigheden bouwt als voorbeeld een dash met een actief venster van 0.2 seconde en een cooldown van 1 seconde, dus met dezelfde timing als de dash uit deze handleiding.
Uitbreiden: animatie, camera en een sprintpass
Renanimatie
Maak een renanimatie in de Animation Editor, geef hem de prioriteit Movement (Roblox raadt die aan voor loop- en renanimaties), publiceer hem en kopieer het asset-ID. Maak in MovementClient een Animation met dat AnimationId, laad hem met Animator:LoadAnimation via de Animator in de Humanoid van het personage, start de track waar het rennen begint en stop hem waar het stopt. Laad hem opnieuw voor elk nieuw personage.
Animaties die je apparaat op je personage afspeelt, ziet iedereen als je de Animator gebruikt die Roblox daar heeft neergezet: tracks die geladen zijn op een Animator die een LocalScript heeft gemaakt, worden niet gerepliceerd. Humanoid:LoadAnimation, dat veel oude tutorials gebruiken, is verouderd.
Een wijdere camera tijdens het rennen
Een iets grotere kijkhoek laat rennen sneller aanvoelen. Tween op dezelfde twee plekken workspace.CurrentCamera.FieldOfView van de standaard 70 naar ongeveer 80 als het rennen begint, en terug als het stopt, bijvoorbeeld met TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox beperkt de waarde tot 1 tot 120 en waarschuwt dat heel lage of heel hoge waarden spelers kunnen desoriënteren. Verandert een ander script in de game ook de kijkhoek, tween dan terug naar de gevonden waarde in plaats van naar 70.
Snel rennen als gamepass
De gamepass-handleiding werkt al met dit script: zijn Speed-perk zet op de server WalkSpeed op 24 voor elk nieuw personage, MovementClient telt daar de sprintbonus bij op, en 34 studs per seconde blijft binnen wat MovementCheck toestaat.
Voor een pass die het rennen zelf sneller maakt, voeg je een pass FastSprint toe aan PassConfig.ids uit die handleiding. Zijn serverscript zet dan het attribuut OwnsPass_FastSprint op de speler zodra de aankoop bevestigd is. Gebruik in MovementClient een grotere bonus dan Config.SPRINT_BONUS als player:GetAttribute("OwnsPass_FastSprint") == true. Geef zulke spelers in MovementCheck een grotere marge door hetzelfde attribuut op de server te lezen, waar de speler het niet kan veranderen, en controleer dat de nieuwe topsnelheid onder wat de controle meldt blijft.
Eén beperking om te kennen: verandert een ander script WalkSpeed midden in het rennen, dan zet het einde van dat rennen de snelheid terug die er daarvoor was. De volgende respawn stelt de snelheid van de pass weer in, omdat het gamepass-script die op elk nieuw personage toepast.
Veelvoorkomende fouten en oplossingen
Open het venster Output (menu Window, dan Output) voordat je op Play klikt. De meeste problemen met deze scripts printen daar een fout of waarschuwing met de naam van het script en het regelnummer.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
MovementClient of MovementCheck wacht op een module die er niet is onder precies die naam. Het moet een ModuleScript zijn met de naam MovementConfig direct in ReplicatedStorage. De handleiding over scriptfouten bespreekt deze waarschuwing uitgebreid.
Shift doet niets
Controleer of ShiftToSprint of MovementClient een LocalScript is, geen Script, en of het in StarterPlayerScripts staat. Met MovementClient moet het personage ook lopen en minstens 20 stamina hebben om te beginnen met rennen, dus houd Shift vast tijdens het bewegen. Gaat in plaats van rennen Shift Lock aan en uit, zie dan de vraag over Shift Lock hieronder.
Het rennen stopt na een paar seconden
Dan is de stamina op: 100 stamina met 20 per seconde is genoeg voor 5 seconden. Verhoog MAX_STAMINA of verlaag DRAIN_PER_SECOND in MovementConfig.
De dash doet niets
De dash heeft 25 stamina nodig, wacht 1 seconde na de vorige en doet niets zolang je zit. Ligt het daar niet aan, dan heeft het root-part van je personage misschien geen Attachment met de naam RootAttachment, wat bij sommige eigen personages voorkomt: voeg hem toe aan de HumanoidRootPart van je StarterCharacter.
De dubbele sprong werkt niet
DoubleJump moet een LocalScript in StarterCharacterScripts zijn, niet in StarterPlayerScripts, want het leest script.Parent als het personage. Druk een tweede keer op springen nadat je van de grond bent: een ingedrukte knop telt niet als nieuwe druk, en van een richel stappen geeft geen sprong in de lucht.
Op de telefoon is er geen knop Sprint of Dash
ContextActionService voegt zijn knoppen alleen toe op touchapparaten, dus op een pc zonder touchscreen zie je ze nooit. Test met een telefoon in de Device Simulator in Studio (dat is een bèta: zet New Device Simulator aan in File, Beta Features en herstart Studio). BindAction kan maximaal 7 touchknoppen maken, dus tel hoeveel andere scripts in de game er maken.
MovementCheck klaagt over eerlijke spelers
De gebruikelijke oorzaken: een teleport uit een ander serverscript, een lopende band of een voertuig, of lag. Zet het attribuut MovementCheckSkip na je eigen teleports (zie Respawns en teleports) en verhoog SPEED_ALLOWANCE als de controle bij normaal spelen nog steeds afgaat.
Een boost verdwijnt na het rennen
Een ander script heeft WalkSpeed veranderd tijdens het rennen, en het rennen zette bij het stoppen de snelheid terug die het bij het begin zag. Geef boosts bij het spawnen van het personage, zoals de gamepass-handleiding doet, zodat een respawn de juiste snelheid weer instelt.
Bouwen met RoCode
Heb je geen zin om dit allemaal met de hand in te stellen, dan kan RoCode het bouwen in de place die je open hebt. RoCode is een onafhankelijke AI-agent voor Roblox Studio, niet van Roblox: je beschrijft de wijziging in de webchat en de plugin voor Studio maakt de scripts in je Explorer, dus je hoeft geen code te plakken.
Voeg sprinten met Shift toe met een staminabalk: loopsnelheid plus 10 zolang Shift ingedrukt is, 100 stamina, verbruik 20 per seconde, herstel 15 per seconde na een seconde rust, een knop Sprint op telefoons, een dash op Q en een dubbele sprong.
- Kan eerst je place doorzoeken met Search Scripts en Read Script om andere scripts te vinden die WalkSpeed veranderen (zoals een gamepass-perk), zodat het rennen daarbij optelt
- Schrijft het ModuleScript, de LocalScripts en de controle op de server met Create Script
- Heeft de opdracht elk geschreven script te laten compileren met Check Script, dat het in Studio compileert zonder het uit te voeren
- Zet een undo-punt voor en na elke batch wijzigingen, dus Ctrl+Z draait één batch tegelijk terug
RoCode kan geen renanimatie maken: maak die in de Animation Editor en plak het ID. Met plugin 3.9.11 of nieuwer kan RoCode een playtest van je game in Studio starten en een testpersonage besturen om te controleren of alles werkt, en met plugin 3.9.15 of nieuwer kan het testpersonage toetsen indrukken, bijvoorbeeld Shift vasthouden en controleren of WalkSpeed omhoog is gegaan. Hij beslist zelf wanneer hij een playtest start, maximaal 2 per build plus 1 om zijn reparatie te controleren, en controleert alleen wat hij zelf heeft gekozen te testen, dus probeer rennen, dash en dubbele sprong zelf, en controleer de telefoonknoppen in de Device Simulator in Studio. Beweging is één systeem van de vele in een game; een hele game maken met RoCode gaat één systeem per prompt, zoals hier. Hoe RoCode verbinding maakt met Studio.
Veelgestelde vragen
Waarom werkt het sprintscript niet op de telefoon?
Een telefoon heeft geen Shift-toets. Koppel rennen met ContextActionService:BindAction en geef true mee als derde argument: dat voegt op touchapparaten een knop op het scherm toe, zoals zowel ShiftToSprint als MovementClient doen.
Moet ik sprinten op de server doen?
Nee. Elk apparaat beweegt zijn eigen personage, dus een WalkSpeed die de server instelt houdt een valsspeler die zijn eigen kan instellen niet tegen, en de nieuwe snelheid komt pas na een heen-en-terugreis, dus het rennen begint met vertraging. Doe het rennen op de client en controleer op de server hoe ver personages echt bewegen, zoals in stap 5. De bèta server authority van Roblox werkt anders, en de bewegingscode moet je daarvoor herschrijven.
Waarom blijft mijn personage rennen als ik Shift loslaat?
Het script heeft het loslaten gemist, meestal omdat het alleen naar het indrukken luistert. ContextActionService stuurt End als de toets wordt losgelaten en Cancel als een andere koppeling hem overneemt; MovementClient stopt bij allebei, en ook als de stamina op is of het personage stopt met bewegen.
Hoe voeg ik een renanimatie toe?
Laad een renanimatie via de Animator in de Humanoid van het personage in hetzelfde LocalScript, start hem als het rennen begint en stop hem als het stopt. Geef hem de prioriteit Movement. Animaties die je op je eigen personage afspeelt, ziet iedereen.
Waarom gaat de dubbele sprong op de telefoon vanzelf af?
Een ingedrukte springknop op een telefoon blijft sprongen vragen. Tel een sprong alleen als nieuw als de verzoeken even zijn gestopt, zoals het script DoubleJump doet.
Wat is de standaard loopsnelheid in Roblox?
16 studs per seconde. Hij komt uit StarterPlayer.CharacterWalkSpeed, dat de Humanoid.WalkSpeed van elk nieuw personage instelt. Het rennen uit deze handleiding telt er 10 bij op, dus rennen gaat op 26.
Hoe snel moet rennen in Roblox zijn?
De meeste games tellen een halve tot een hele loopsnelheid erbij op: 16 wordt iets tussen 24 en 32. Kort, langzaam rennen past bij horror, lang en snel rennen bij grote maps. De presets per type game geven voor elk de loopsnelheid, de sprintbonus en de staminagetallen.
Hoe maak ik rennen met stamina?
Bewaar een staminagetal op het apparaat van de speler, verbruik het elk frame tijdens het rennen en herstel het na een korte rust, beide keren met de frametijd, en stop het rennen als het op 0 staat. MovementClient uit stap 3 doet dat met een balk op het scherm; de getallen staan in MovementConfig.
Hoe ren je met een controller in Roblox?
Koppel ButtonL3 van de gamepad (de linkerstick indrukken) via ContextActionService samen met Left Shift, zoals beide scripts hier doen. ShiftToSprint maakt L3 een schakelaar, want de stick ingedrukt houden en er tegelijk mee sturen is vermoeiend.
Botst sprinten met Shift met Shift Lock?
Dat kan. Spelers die Shift Lock in de Roblox-instellingen hebben aangezet, wisselen het met de Shift-toets, dus één toets doet twee dingen. De documentatie van Roblox zegt dat de API's van Shift Lock worden uitgefaseerd. Hindert het conflict je spelers, zet StarterPlayer.EnableMouseLockOption dan uit of koppel het rennen in MovementClient aan een andere toets, zoals Left Ctrl.
Bronnen en verder lezen
- Roblox Creator Docs: ContextActionService (in het Engels). BindAction, touchknoppen, de limiet van 7 knoppen en waarom hij in de meeste gevallen beter is dan InputBegan
- Roblox Creator Docs: Humanoid (in het Engels). WalkSpeed en de opmerking over beveiliging, MoveDirection, StateChanged en ChangeState met een voorbeeld van een dubbele sprong
- Roblox Creator Docs: LinearVelocity (in het Engels). de modus Plane, tangentiële assen en MaxForce
- Roblox Creator Docs: Mover constraints (in het Engels). overstappen van het verouderde BodyVelocity naar LinearVelocity
- Roblox Creator Docs: UserInputService (in het Engels). JumpRequest en waarom hij een debounce nodig heeft
- Roblox Creator Docs: Network ownership, movement validation, and physics (in het Engels). wat de client bestuurt, afstandscontroles, lekkende emmers en uitzonderingen voor teleports
- Roblox Creator Docs: Server authority model (in het Engels). het model met beweging op de server, BindToSimulation en de Workspace-instellingen die het nodig heeft
- Roblox Creator Docs: Input Action System (in het Engels). het voorbeeld Character Sprint met InputAction en InputBinding
- Roblox Creator Docs: Custom abilities (in het Engels). de dashvaardigheid in de Character Controller Library
- Roblox Creator Docs: Studio testing modes (in het Engels). Device Simulator en Controller Emulator
Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.