Tutorial · Gamesystemen

Sprinten met Shift in Roblox Studio voor pc, telefoon en console

Sprinten met Shift in Roblox komt neer op één getal: de WalkSpeed van de Humanoid, die omhooggaat zolang Shift ingedrukt is. Stap 1 doet precies dat in één kort LocalScript, dat ook werkt met de knop Sprint op een telefoon en met een gamepad. De rest van de handleiding voegt toe wat een grote game nodig heeft: een staminabalk, een dash met moderne physics, een dubbele sprong die niet afgaat door een ingedrukte knop, en inzicht in wat de server wel en niet kan controleren.

Bijgewerkt 20 november 202628 min lezenAuteur:

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
  1. Hoe het werkt
  2. 1. Sprinten met Shift
  3. 2. Instellingenmodule
  4. 3. Rennen en dash
  5. 4. Dubbele sprong
  6. 5. Controle op de server
  7. 6. Testen
  8. Snelheidspresets
  9. Oude scripts
  10. Input Action System
  11. Uitbreidingen
  12. Common errors
  13. Met RoCode
  14. Veelgestelde vragen
  15. Bronnen en verder lezen

Hoe sprinten werkt in Roblox

IllustratieShift laat je rennen met WalkSpeed 26 terwijl de balk leegloopt, Q doet een dash voor een kwart balk, en een tweede druk op springen in de lucht springt nog een keer.

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.

Waaruit het bewegingssysteem bestaat
OnderdeelWaar het staatWat het doet
LocalScript ShiftToSprintStarterPlayerScriptsStap 1 op zichzelf: rennen op toetsenbord, telefoon en gamepad, zonder stamina. Als je stamina en dash toevoegt, vervangt MovementClient het.
ModuleScript MovementConfigReplicatedStorageDe getallen: sprintbonus, stamina en dash. Zowel het LocalScript als de controle op de server lezen ze.
LocalScript MovementClientStarterPlayerScriptsKoppelt Sprint en Dash aan een toets, een gamepadknop en een touchknop, draait de staminalus, tekent de balk en doet de dash.
LocalScript DoubleJumpStarterCharacterScriptsGeeft één extra sprong in de lucht. In elk nieuw personage start een nieuwe kopie.
Script MovementCheckServerScriptServiceMeet hoe ver elk personage echt beweegt en schrijft een waarschuwing naar Output als iemand lange tijd sneller beweegt dan rennen en dash toelaten.
De Explorer als het bewegingssysteem klaar is
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.

  1. 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.
  2. Vervang de inhoud door de code hieronder en klik op Play.
LocalScript in StarterPlayerScripts met de naam ShiftToSprint
-- 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?

Hoe ShiftToSprint op elk apparaat werkt als TOGGLE_ON_TOUCH_AND_GAMEPAD true is
Apparaat en invoerWerkt alsWaarom
Toetsenbord: Left ShiftVasthoudenEen toets vasthouden tijdens het bewegen is makkelijk, en loslaten stopt het rennen meteen.
Gamepad: linkerstick indrukken (L3)WisselenDe stick ingedrukt houden en er tegelijk mee sturen is vermoeiend.
Telefoon of tablet: knop Sprint op het schermWisselenEen 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.

  1. Ga in de Explorer met de muis over ReplicatedStorage, klik op de knop + en voeg een ModuleScript toe.
  2. Hernoem het naar MovementConfig en vervang de inhoud door de code hieronder.
ModuleScript in ReplicatedStorage met de naam MovementConfig
-- 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
Wat elke instelling doet
InstellingWaardeEffect
SPRINT_BONUS10Komt bij WalkSpeed tijdens het rennen. De standaard-WalkSpeed in Roblox is 16, dus rennen gaat met 26 studs per seconde.
MAX_STAMINA100Een volle balk.
DRAIN_PER_SECOND20Een volle balk is genoeg voor 5 seconden rennen.
REGEN_PER_SECOND15Een lege balk vult zich in ongeveer 6.7 seconden.
REGEN_DELAY1Seconden rust voordat het herstel begint.
MIN_TO_START20Stamina die nodig is om te beginnen met rennen.
DASH_SPEED60Studs per seconde tijdens de dash.
DASH_SECONDS0.2Hoe lang de dash duurt: ongeveer 12 studs bij 60 studs per seconde.
DASH_COST25Stamina per dash.
DASH_COOLDOWN1Seconden 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.

  1. Klap in de Explorer StarterPlayer open, ga met de muis over StarterPlayerScripts en voeg een LocalScript toe met de naam MovementClient.
  2. Vervang de inhoud door de code hieronder.
LocalScript in StarterPlayerScripts met de naam MovementClient
-- 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.

  1. Klap in de Explorer StarterPlayer open, ga met de muis over StarterCharacterScripts en voeg een LocalScript toe met de naam DoubleJump.
  2. Vervang de inhoud door de code hieronder.
LocalScript in StarterCharacterScripts met de naam DoubleJump
-- 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.

  1. Ga met de muis over ServerScriptService en voeg een Script toe met de naam MovementCheck.
  2. Vervang de inhoud door de code hieronder.
Script in ServerScriptService met de naam MovementCheck
-- 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.

Wat de controle vangt, gerekend met haar getallen
ValsspelerWat MovementCheck doet
Zet WalkSpeed op 100Waarschuwt na ongeveer een seconde rennen
Zet WalkSpeed op 50Waarschuwt 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 keerWaarschuwt bij de volgende controle
Rent met een snelheid tot 38 studs per seconde, ongeveer anderhalf keer zo snel als rennenNiets: onder 38.5 studs per seconde loopt de emmer even snel leeg als hij volloopt
Verandert zijn MovementConfig voor eindeloze staminaNiets: rennen op 26 studs per seconde mag zo lang als je wilt
Vliegt, springt zonder grens of loopt door murenNiets: 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:

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

  1. 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.
  2. Laat Shift los. Na 1 seconde begint de balk te vullen. Zolang hij nog geen vijfde vol is, doet Shift niets.
  3. 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_SPEED of DASH_SECONDS in MovementConfig.
  4. 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.
  5. Houd Space de hele sprong ingedrukt. Je moet één sprong maken, niet twee, want de sprong in de lucht heeft een nieuwe druk nodig.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. Staat Workspace.PlayerScriptsUseInputActionSystem in je place op Enabled, test de dubbele sprong dan nog een keer: de documentatie van Roblox zegt niet of JumpRequest zich 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.

Loopsnelheid, rennen en stamina per type game. Rentijd is MAX_STAMINA / DRAIN_PER_SECOND; herstel is MAX_STAMINA / REGEN_PER_SECOND plus 1 seconde REGEN_DELAY
Type gameCharacterWalkSpeedSPRINT_BONUS (rensnelheid)DRAIN_PER_SECONDREGEN_PER_SECONDVolledig rennenVan leeg tot volAfstand op één balk
Deze handleiding1610 (26)20155 s7.7 s130 studs
Achtervolging in horror128 (20)25104 s11 s80 studs
Battlegrounds en gevechten1612 (28)15206.7 s6 songeveer 187 studs
Open wereld of simulator1616 (32)102510 s5 s320 studs
Obby of parkour168 (24)zonder stamina: gebruik ShiftToSprint
  • De loopsnelheid stel je in StarterPlayer in. Selecteer StarterPlayer en stel CharacterWalkSpeed in (standaard 16). Elk nieuw personage begint met die snelheid, rennen telt er SPRINT_BONUS bij 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.

Trucs uit oude tutorials en wat deze handleiding in plaats daarvan doet
TrucWat het probleem isDeze handleiding
BodyVelocity voor een dashVerouderd: Roblox zegt dat je in plaats daarvan LinearVelocity moet gebruikenLinearVelocity in de modus Plane
Een lus op RunService.RenderSteppedVoor nieuw werk is die vervangen door PreRender. Gamelogica zoals stamina hoort op Heartbeat, dat Roblox beschrijft voor terugkerende taken zoals het herstellen van gezondheidHeartbeat 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 ongelijkmatigVerbruik en herstel elk frame met deltaTime
UserInputService.InputBegan zonder chatcontroleEen druk op Shift tijdens het typen van een chatbericht start het rennenContextActionService, dat ook een knop op de telefoon toevoegt
WalkSpeed = 16 bij loslaten of elk frameOverschrijft elke andere snelheid, zoals een gamepass-perkVerandert 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 insteltExploiters stellen hun WalkSpeed toch zelf in, en het rennen begint met de vertraging van een heen-en-terugreisRennen op de client plus een afstandscontrole op de server
Dubbele sprong bij elke JumpRequestJumpRequest gaat meerdere keren af per sprongverzoek, en een ingedrukte knop kan sprongen blijven vragenEen 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 touchscreenContextActionService voegt op touchapparaten knoppen op het scherm toe zonder je eigen apparaatcontrole
Humanoid:LoadAnimation voor een renanimatieVerouderd ten gunste van Animator:LoadAnimationDe 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.

Jij typt

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.

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

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.

Probeer RoCode in je eigen game.

Elke dag gratis credits, geen creditcard nodig. Installeer de plugin, beschrijf een functie en kijk wat er in Studio verschijnt.