Tutorial · Spilsystemer

Sådan laver du sprint med Shift i Roblox Studio til PC, telefon og konsol

Sprint med Shift i Roblox handler om ét tal: WalkSpeed på Humanoid, som stiger, mens Shift holdes nede. Trin 1 gør præcis det i ét kort LocalScript, der også virker med Sprint-knappen på telefonen og med gamepad. Resten af guiden tilføjer det, et større spil har brug for: en stamina-bjælke, en dash med moderne fysik, et dobbelthop, der ikke udløses af en holdt knap, og en forståelse af, hvad serveren kan tjekke, og hvad den ikke kan.

Opdateret 20. november 202625 min. læsningSkrevet af

Kort fortalt

Læg ét LocalScript i StarterPlayerScripts, der binder handlingen Sprint med ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Mens Shift holdes nede, lægger du 10 til Humanoid.WalkSpeed (16 bliver til 26), og når den slippes, sætter du den tidligere værdi tilbage. Argumentet true tilføjer en Sprint-knap på touchskærme, og i scriptet fra denne guide slår den knap og L3 på gamepad sprint til og fra i stedet for at virke, mens de holdes.

  • Læg til den nuværende WalkSpeed i stedet for at sætte 26, så en hastighedsforøgelse fra et gamepass bevares.
  • Sprint kører på spillerens enhed. Serveren kan ikke gennemtvinge WalkSpeed; den kan kun måle, hvor langt karakterer flytter sig, og markere hastigheder, som sprint ikke kan forklare.
  • En stamina-bjælke, en dash og et dobbelthop efter samme idé tilføjes i trin 2 til 4. Hvor hurtigt og hvor længe der skal sprintes, får du hjælp til i presets efter spiltype med tal til horror, kamp og åben verden.
På denne side
  1. Sådan virker det
  2. 1. Sprint med Shift
  3. 2. Indstillingsmodul
  4. 3. Sprint og dash
  5. 4. Dobbelthop
  6. 5. Tjek på serveren
  7. 6. Test
  8. Hastigheds-presets
  9. Gamle scripts
  10. Input Action System
  11. Udvidelser
  12. Common errors
  13. Med RoCode
  14. Ofte stillede spørgsmål
  15. Kilder og videre læsning

Sådan virker sprint i Roblox

IllustrationShift giver sprint med WalkSpeed 26, mens bjælken falder, Q laver en dash for en fjerdedel af bjælken, og et andet tryk på hop i luften hopper igen.

Hver spillers enhed flytter spillerens egen karakter. Tastaturet, controlleren eller touchskærmen bestemmer, hvor karakteren går hen, og Roblox sender resultatet til serveren og til alle andre. Derfor er sprint et LocalScript, der hæver Humanoid.WalkSpeed, mens en tast holdes nede, og det er alt, hvad trin 1 gør. Resten af guiden er det, et større spil har brug for omkring det: en stamina-bjælke, en dash, et dobbelthop og et tjek på serveren mod snydere.

Hvad bevægelsessystemet består af
ElementHvor det liggerHvad det gør
LocalScript ShiftToSprintStarterPlayerScriptsTrin 1 alene: sprint på tastatur, telefon og gamepad, uden stamina. Når du tilføjer stamina og dash, erstattes det af MovementClient.
ModuleScript MovementConfigReplicatedStorageTallene: sprintbonus, stamina og dash. Både LocalScriptet og tjekket på serveren læser dem.
LocalScript MovementClientStarterPlayerScriptsBinder Sprint og Dash til en tast, en gamepad-knap og en touchknap, kører stamina-løkken, tegner bjælken og laver dashen.
LocalScript DoubleJumpStarterCharacterScriptsGiver ét ekstra hop i luften. En ny kopi starter i hver ny karakter.
Script MovementCheckServerScriptServiceMåler, hvor langt hver karakter faktisk flytter sig, og skriver en advarsel i Output, når nogen i længere tid bevæger sig hurtigere, end sprint og dash tillader.
Explorer, når bevægelsessystemet er færdigt
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Hvis forskellen mellem Script og LocalScript er ny for dig, så forklarer Script, LocalScript og ModuleScript, hvor hver slags kører, og hvorfor.

Trin 1: sprint med Shift i ét LocalScript

Hvis du kun har brug for hurtigere løb, mens Shift holdes nede, er dette ene script nok. Det giver også telefoner en Sprint-knap på skærmen og lader dig sprinte med venstre stick på en gamepad.

  1. I Explorer folder du StarterPlayer ud, holder musen over StarterPlayerScripts, klikker på knappen + og indsætter et LocalScript med navnet ShiftToSprint.
  2. Erstat indholdet med koden nedenfor, og tryk på Play.
LocalScript i StarterPlayerScripts med navnet ShiftToSprint
-- LocalScript i StarterPlayer > StarterPlayerScripts med navnet ShiftToSprint.
-- Hold Left Shift nede for at sprinte. På en gamepad trykker du på venstre stick (L3) for at
-- slå sprint til eller fra. På en telefon trykker du på Sprint-knappen for at slå den til eller fra.

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

-- Indstillinger
local SPRINT_BONUS = 10 -- lægges til WalkSpeed under sprint (16 bliver til 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: knappen skal holdes nede

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- den WalkSpeed, der skal vendes tilbage til

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
		-- Husk den nuværende hastighed, og læg til den, så en forøgelse fra et andet script bevares
		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
		-- Hold: sprint, mens tasten eller knappen er trykket ned
		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
		-- Skift: hvert tryk slår sprint til eller fra
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Ét kald binder tasten, gamepad-knappen og, på touchskærme, en knap på skærmen
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- En ny karakter starter med at gå: dens Humanoid har allerede den normale WalkSpeed
player.CharacterAdded:Connect(function()
	sprinting = false
end)

Ændr SPRINT_BONUS for at gøre sprinten hurtigere eller langsommere. Sæt TOGGLE_ON_TOUCH_AND_GAMEPAD til false, så knappen på telefonen og L3 virker som Shift: sprint kun, mens de holdes nede.

BindAction binder én handling til Left Shift og til L3-knappen på gamepad, og dens tredje argument, true, tilføjer en knap på touchskærme; SetTitle skriver "Sprint" på den. Handleren får også selve inputtet, så den kan skelne et tryk på tastaturet fra en gamepad eller en touchknap. Når sprinten starter, husker scriptet den nuværende WalkSpeed og lægger SPRINT_BONUS til; når den slutter, sætter det den huskede værdi tilbage. En hastighed, som et andet script har sat, for eksempel Speed-fordelen fra gamepass-guiden, bevares. En ny karakter starter med den normale WalkSpeed, så CharacterAdded-handleren nulstiller kun flaget.

Hold eller skift?

Sådan virker ShiftToSprint på hver enhed, når TOGGLE_ON_TOUCH_AND_GAMEPAD er true
Enhed og inputVirker somHvorfor
Tastatur: Left ShiftHoldDet er nemt at holde tasten nede, mens man bevæger sig, og når den slippes, stopper sprinten med det samme.
Gamepad: tryk på venstre stick (L3)SkiftDet er trættende at holde sticken trykket ind og samtidig styre med den.
Telefon eller tablet: Sprint-knappen på skærmenSkiftEn tommelfinger, der holder knappen, kan ikke samtidig trykke på Jump.

For at teste trykker du på Play og holder Shift nede, mens du går: hastigheden stiger fra 16 til 26 studs i sekundet, og hvis du slipper, sætter du farten ned. Til telefon vælger du en telefon i Device Simulator i Studio, trykker på Play og trykker på Sprint én gang for at starte og én gang til for at stoppe. Til gamepad åbner du Controller Emulator under en playtest og trykker på L3. Den fulde liste over tjek pr. enhed findes i trin 6.

Trin 2 og 3 erstatter dette script med et andet med stamina-bjælke og dash. Trin 4 og 5 tilføjer dobbelthop og tjekket på serveren og virker med begge scripts.

Trin 2: tallene for stamina og dash i ét modul

Til en sprint, der løber tør, skifter trin 2 og 3 ShiftToSprint ud med et større LocalScript med stamina-bjælke og dash. Slet først ShiftToSprint: begge scripts binder handlingen Sprint.

Alle tallene ligger i ét ModuleScript, så følelsen af bevægelsen justeres ét sted. MovementClient læser dem på hver spillers enhed, og MovementCheck læser det samme modul på serveren for at vide, hvor hurtig sprint og dash skal være.

  1. I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og indsætter et ModuleScript.
  2. Omdøb det til MovementConfig, og erstat indholdet med koden nedenfor.
ModuleScript i ReplicatedStorage med navnet MovementConfig
-- Ét sæt tal til bevægelses-LocalScriptet og hastighedstjekket på serveren.

local MovementConfig = {
	SPRINT_BONUS = 10, -- lægges til den nuværende WalkSpeed: 16 (Robloxs standard) bliver til 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 sekunders sprint fra en fuld bjælke
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- sekunder efter sprintens slutning, før stamina begynder at komme tilbage
	MIN_TO_START = 20, -- den stamina, der kræves for at starte en sprint, så en tom bjælke ikke blinker

	DASH_SPEED = 60, -- studs i sekundet under en dash
	DASH_SECONDS = 0.2, -- så dækker en dash omkring 12 studs
	DASH_COST = 25, -- stamina
	DASH_COOLDOWN = 1,
}

return MovementConfig
Hvad hver indstilling gør
IndstillingVærdiEffekt
SPRINT_BONUS10Lægges til WalkSpeed under sprint. WalkSpeed i Roblox er som standard 16, så sprint går med 26 studs i sekundet.
MAX_STAMINA100En fuld bjælke.
DRAIN_PER_SECOND20En fuld bjælke rækker til 5 sekunders sprint.
REGEN_PER_SECOND15En tom bjælke fyldes op på cirka 6.7 sekunder.
REGEN_DELAY1Sekunders hvile, før stamina begynder at komme tilbage.
MIN_TO_START20Den stamina, der kræves for at starte en sprint.
DASH_SPEED60Studs i sekundet under en dash.
DASH_SECONDS0.2Hvor længe en dash varer: omkring 12 studs ved 60 studs i sekundet.
DASH_COST25Stamina pr. dash.
DASH_COOLDOWN1Sekunder mellem dashes.

Hver side kører sin egen kopi af modulet (et modul køres én gang på hver side), så en spiller, der ændrer disse tal på sin enhed, ændrer kun sin egen kopi. Men her beskytter det ikke noget: spillerens enhed flytter alligevel karakteren og kan give sig selv uendelig stamina, uanset hvad der står i modulet. Tjekket på serveren i trin 5 er bygget med det i tankerne.

Trin 3: sprint med stamina og dash

Dette LocalScript laver det, spillerne mærker. Det binder Sprint og Dash, tegner stamina-bjælken, kører stamina-løkken hvert frame og laver dashen.

  1. I Explorer folder du StarterPlayer ud, holder musen over StarterPlayerScripts og indsætter et LocalScript med navnet MovementClient.
  2. Erstat indholdet med koden nedenfor.
LocalScript i StarterPlayerScripts med navnet MovementClient
-- Hold Shift (eller L3, eller Sprint-knappen på telefonen) nede for at sprinte, så længe der er stamina.
-- Tryk på Q (eller B, eller Dash-knappen) for at lave en dash i bevægelsesretningen.

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 -- den WalkSpeed, der skal vendes tilbage til, når sprinten slutter
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Stamina-bjælken: en ramme med en udfyldning, hvis bredde svarer til den 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

-- Sprint: her kun et flag; Heartbeat-løkken nedenfor afgør hvert frame, om der skal sprintes
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Kun tryk og slip ændrer det: en finger, der glider over touchknappen, sender 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()
	-- Ingen dash, mens man sidder: en siddende karakter er svejset til sædet, så den ville skubbe hele køretøjet
	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 -- sæt genopfyldningen på pause, ligesom sprint gør

	-- Dash derhen, hvor spilleren bevæger sig, eller derhen, hvor den kigger, hvis den står stille
	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 i Plane-tilstand holder den vandrette hastighed og lader tyngdekraften være
	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

-- Hvert kald binder en tast, en gamepad-knap og, på touchenheder, en knap på skærmen
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")

-- Hvert frame: brug stamina under sprint og bevægelse, fyld op efter en kort hvile
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

	-- Ændr kun WalkSpeed ved sprintens start og slutning, så en hastighed, som et andet
	-- script har sat (for eksempel et speed-pass), bevares, og sprinten lægges oven i den
	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)

-- En ny karakter starter med fuld stamina, og intet holdes nede
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- en ny Humanoid starter med den normale WalkSpeed
end)

Stamina-bjælken oprettes i koden med ResetOnSpawn sat til false, så den bliver på skærmen efter respawn, og CharacterAdded-handleren nederst fylder den op igen for hver ny karakter. Linjerne med type Config beskriver, hvad modulet returnerer, så streng typekontrol fanger en tastefejl i et indstillingsnavn; under spillet ændrer de ingenting.

Tastatur, gamepad og knap på telefonen med ét kald

ContextActionService:BindAction tager handlingens navn, en handlerfunktion, om der skal oprettes en touchknap, og derefter inputs. Hvis du sender true som tredje argument, tilføjer ContextActionService en knap på skærmen på touchenheder, inde i en ScreenGui med navnet ContextActionGui i spillerens PlayerGui. SetTitle skriver "Sprint" og "Dash" på knapperne. BindAction kan højst oprette 7 touchknapper, så hold øje med antallet, hvis andre scripts i spillet også bruger dem.

Handleren får inputtets tilstand: Begin ved tryk og End ved slip. onSprint husker kun, om Sprint holdes nede. Den regner også Cancel som et slip, som ContextActionService sender, når en anden binding overtager inputtet, og ignorerer Change, som en finger, der bevæger sig over touchknappen, kan sende. Begge handlere returnerer Pass, så den næste binding på samme tast også får inputtet.

Roblox-referencen for ContextActionService anbefaler den frem for UserInputService.InputBegan i de fleste tilfælde. Dens eksempel: et bilhorn på H, der ikke skal dytte, mens spilleren skriver i chatten. En binding udløses kun, så længe den er den seneste for det input, så når chatten overtager tastaturet, behøver du ikke at tjekke noget. Gamepad-inputs: ButtonL3 (tryk på venstre stick, som holdes under bevægelse) og ButtonB. Robloxs eget sprint-eksempel bruger ButtonY, så skift KeyCode i BindAction, hvis det passer bedre til dit spil.

Stamina-løkken

RunService.Heartbeat udløses hvert frame efter fysiktrinnet og sender deltaTime, antallet af sekunder siden sidste frame. Hvis du ganger forbrugs- og genopfyldningshastigheden med den, rækker en fuld bjælke til 5 sekunder, uanset om spillet kører med 30 eller 240 frames i sekundet.

Hvert frame afgør løkken, om karakteren skal sprinte: Sprint holdes nede, karakteren går (Humanoid.MoveDirection er nulvektoren, når den står stille), og der er stadig stamina. For at starte en sprint kræves mindst MIN_TO_START (20); for at fortsætte er alt over 0 nok. Uden denne margin ville en tom bjælke, der fyldes en lille smule hvert frame, slå sprint til og fra hvert frame. Genopfyldningen starter REGEN_DELAY (1 sekund) efter den seneste sprint eller dash, så når spilleren har tømt bjælken, venter den omkring 2.3 sekunder, før den kan sprinte igen.

WalkSpeed ændres kun i det frame, hvor sprinten starter eller slutter. Ved start husker scriptet den nuværende WalkSpeed og lægger SPRINT_BONUS til; ved slut sætter det den huskede værdi tilbage. Derfor bevares en hastighed, som et andet script har sat: Speed-fordelen fra gamepass-guiden sætter WalkSpeed til 24, og med dette script sprinter dens ejere med 34. Et script, der skriver WalkSpeed = 16 hvert frame eller ved hvert slip, ville ubemærket annullere den fordel.

Dash

En dash skubber karakteren derhen, hvor den bevæger sig, eller derhen, hvor den kigger, hvis den står stille, og retningen gøres vandret, så den aldrig peger op eller ned. Den koster 25 stamina, sætter genopfyldningen på pause ligesom sprint og har en cooldown på 1 sekund. Den tjekker ikke for jord, så den virker også i luften, hvilket passer godt med dobbelthop. Mens karakteren sidder, gør dashen ingenting: en siddende karakter er svejset til sædet, og i et køretøj kunne skubbet flytte hele køretøjet.

Skubbet er en LinearVelocity-constraint på rodpartens RootAttachment. I Plane-tilstand med akserne X og Z holder den en vandret hastighed på 60 studs i sekundet og rører ikke den lodrette, så tyngdekraften virker, og en dash ud over en kant falder som normalt. MaxForce er math.huge, så skubbet er ubegrænset. Debris:AddItem destruerer constrainten efter DASH_SECONDS uden at få scriptet til at vente, så dashen varer 0.2 sekund, omkring 12 studs ved den hastighed.

Gamle tutorials bruger BodyVelocity, som Roblox har markeret som forældet med besked om at bruge LinearVelocity i stedet. Dens trick med MaxForce på nul langs én akse erstattes af tilstandene Line, Plane og Vector på LinearVelocity. Da spillerens enhed selv simulerer sin karakter, flytter en constraint, der er oprettet af et LocalScript, karakteren, og andre spillere ser dashen som enhver anden bevægelse.

Robloxs egen UI-tutorial fastgør constrainten til humanoid.RootPart.RootAttachment på præcis samme måde. Hvis dit spil har en egen karakter, hvis rodpart ikke har en Attachment med navnet RootAttachment, gør dashen ingenting: tilføj den til HumanoidRootPart i din StarterCharacter.

Trin 4: dobbelthop

Dobbelthoppet bor i sit eget LocalScript i StarterCharacterScripts. Roblox lægger en kopi af scripts fra den container i hver karakter ved spawn, og de kopier overlever ikke respawn, så hvert liv starter med et frisk script, og intet overføres fra det forrige.

  1. I Explorer folder du StarterPlayer ud, holder musen over StarterCharacterScripts og indsætter et LocalScript med navnet DoubleJump.
  2. Erstat indholdet med koden nedenfor.
LocalScript i StarterCharacterScripts med navnet DoubleJump
-- Giver ét ekstra hop i luften. Starter forfra for hver ny karakter,
-- så intet overføres efter respawn.

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 udløses flere gange for ét tryk
local NEW_PRESS_GAP = 0.1 -- en holdt hopknap bliver ved med at sende JumpRequest; en pause af denne længde betyder, at den er sluppet

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
		-- Et hop fra jorden (ikke et af vores hop i luften) giver hop i luften tilbage
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest udløses, når spilleren beder om et hop, for eksempel med Space eller hopknappen på telefonen
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Kun et nyt tryk hopper igen, så en holdt knap ikke bruger hoppet i luften
	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)

Sæt EXTRA_JUMPS til 2 for et tredobbelt hop.

Scriptet følger karakterens tilstand via Humanoid.StateChanged. Et skift til Jumping, der ikke kom fra Freefall, er et hop fra jorden, så det giver et hop i luften, og Landed tager det igen. Hvis man går ud over en kant, kommer karakteren i Freefall uden hop, så den får intet hop i luften. Hvis du også vil have det der, så sæt jumpsLeft også ved skift til Freefall fra enhver tilstand undtagen Jumping.

UserInputService.JumpRequest udløses, når spilleren beder om et hop, for eksempel med Space eller hopknappen på telefonen. Roblox-referencen advarer om, at den udløses flere gange for én hopforespørgsel, og anbefaler debounce, så scriptet ignorerer forespørgsler i 0.25 sekund efter det seneste hop. En holdt hopknap kan også blive ved med at bede om hop og ville bruge hoppet i luften i samme øjeblik, som karakteren letter fra jorden, så en forespørgsel tæller kun som et nyt tryk efter 0.1 sekund uden forespørgsler.

Selve hoppet i luften er Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Roblox-referencen siger, at det skal kaldes fra et LocalScript på den enhed, der har network ownership over karakteren, og som standard er det spillerens egen enhed, ikke serveren. Kodeeksemplet til ChangeState i referencen er netop et dobbelthop.

Trin 5: fang speedhacks på serveren

Sprint-tutorials stopper ofte ved klienten. Et server-Script kan ikke stole på spillerens WalkSpeed, fordi exploitere ændrer den på deres enhed, men det kan se, hvor deres karakter ender. MovementCheck måler det to gange i sekundet og skriver en advarsel i Output, når nogen i længere tid bevæger sig hurtigere, end sprint og dash tillader. Tallene for sprint og dash læser det fra MovementConfig, så tilføj det modul fra trin 2, selv om du har beholdt ShiftToSprint.

  1. Hold musen over ServerScriptService, og indsæt et Script med navnet MovementCheck.
  2. Erstat indholdet med koden nedenfor.
Script i ServerScriptService med navnet MovementCheck
-- Spillernes enheder flytter deres egne karakterer, så en exploiter kan sætte en hvilken som helst WalkSpeed.
-- Dette tjek måler, hvor langt hver karakter faktisk flytter sig, og skriver i Output,
-- når nogen i længere tid bevæger sig hurtigere, end sprint og dash tillader. Det advarer kun:
-- lag, teleporter og transportbånd kan ligne for høj hastighed, så justér det, før du straffer nogen.

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 -- sekunder
-- Sprinthastighed plus margin til lag. Hæv den, hvis du sælger hastighedsforøgelser.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- margin til en eller to dashes
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- hvor hurtigt tidligere dashes tilgives

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- den rodpart, lastPosition er målt på
local excess: { [Player]: number } = {} -- studs over tolerancen, tilgives gradvist

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
			-- En respawn er en ny rodpart, og en teleport på serveren (rundestart, checkpoint)
			-- sætter attributten nedenfor: begynd at måle forfra i stedet for at markere springet
			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
				-- Kun vandret bevægelse: at falde hurtigt er ikke snyd
				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

Advarslen vises i Output i Studio. I det live spil havner den i serverloggen i Developer Console, som du kan læse som spillets ejer: se output i det live spil.

Hvad det måler

Hvert halve sekund læser scriptet positionen af hver karakters rodpart og måler, hvor langt den har flyttet sig vandret siden sidste tjek. Højden ignoreres, så fald og hop tæller aldrig med; Robloxs råd om bevægelsestjek foreslår den samme projektion på XZ-planet til spil, hvor man går på jorden. Tolerancen er standardganghastigheden plus sprintbonussen og en fjerdedel mere til lag: 32.5 studs i sekundet. Afstand ud over det havner i en "utæt spand", en akkumulator, som Robloxs dokumentation siger passer mange udviklere godt til korte ryk. Spanden mister 3 studs ved hvert tjek, og scriptet advarer, når den indeholder mere end 24 studs, hvilket er en margin på cirka to dashes.

Hvad tjekket fanger, hvis man regner med dets tal
SnyderHvad MovementCheck gør
Sætter WalkSpeed til 100Advarer efter cirka et sekunds løb
Sætter WalkSpeed til 50Advarer efter cirka 2.5 sekunders løb
Laver dashes i træk uden cooldown (60 studs i sekundet)Advarer efter cirka 1.5 sekund
Teleporterer mere end 43 studs ad gangenAdvarer ved næste tjek
Løber med op til 38 studs i sekundet, cirka halvanden gang sprinthastighedenIntet: under 38.5 studs i sekundet tømmes spanden lige så hurtigt, som den fyldes
Ændrer sin MovementConfig for at få uendelig staminaIntet: sprint med 26 studs i sekundet er tilladt så længe, man vil
Flyver, hopper uden begrænsning eller går gennem væggeIntet: tjekket ignorerer højden og ser ikke på kollisioner

Så tjekket fanger grov snyd, hvor en spiller er tydeligt hurtigere end alle andre, og lader den forsigtige slippe igennem. Det er den ærlige grænse for et afstandstjek og grunden til, at Roblox laver noget stærkere (se server authority nedenfor).

Hvorfor det kun advarer

Robloxs dokumentation nævner, at simple hastighedstjek kan markere ærlige spillere med en ustabil forbindelse og går i stykker i spil med køretøjer eller anden kompleks bevægelse. Lagspring, transportbånd, køretøjer, eksplosioner, der kaster karakterer væk, og dine egne teleporter kan ligne for høj hastighed, så scriptet skriver kun en advarsel. Hold øje med Output, mens du og dine testere spiller som normalt, hæv SPEED_ALLOWANCE, hvis ærlige spillere snubler over den, og tilføj en straf, for eksempel at sætte spilleren tilbage, først når tjekket er tavst i almindeligt spil. Hvis eksplosioner i dit spil kaster karakterer væk, så spring også spillere over, hvis Humanoid ikke har mere liv.

Respawns og teleporter

En respawn opretter en ny rodpart, og scriptet begynder at måle forfra, når det ser den, så at dø langt fra spawnpunktet tæller aldrig som for høj hastighed. Teleporter, som dine egne server-scripts laver, har brug for en undtagelse, som Robloxs dokumentation siger om ethvert spil med teleporter. Efter en teleport tilføjer du player:SetAttribute("MovementCheckSkip", true), så begynder næste tjek at måle fra den nye position i stedet for at markere springet:

Pladerne og menuen fra teleport-guiden og Finish-pladen fra guiden til dit første spil sætter den allerede efter hver flytning.

Kun værdien fra serveren tæller. En attribut, som spilleren sætter på sin enhed, bliver på den enhed (se hvad der replikeres, og hvad der ikke gør), så en snyder kan ikke slå tjekket fra med den.

Løsningen for fremtiden: server authority

Robloxs sikkerhedsdokumentation kalder modellen server authority, i skrivende stund i beta, den mest pålidelige måde at stoppe bevægelses-exploits på. Serveren bliver kilden til sandheden, og spillernes enheder sender kun deres input, hvilket ifølge dokumentationen forhindrer speedhacks i at virke, fordi enheden aldrig får lov til selv at melde sin position.

Overgangen er en omskrivning, ikke en justering. I den model beregner serveren bevægelsen, så WalkSpeed eller LinearVelocity, som kun et LocalScript sætter, annulleres, når tilstanden fra serveren kommer. I Robloxs dokumentation står der, at hovedlogikken skal køre i RunService:BindToSimulation()-funktioner i et ModuleScript, som både klienten og serveren kører. Modellen kræver også nogle Workspace-indstillinger, herunder PlayerScriptsUseInputActionSystem, så din styring flytter også over på Input Action System. Behold versionen fra denne guide, indtil du har flyttet sprint, stamina og dash over i den opbygning. Indtil da er et afstandstjek som dette netop det, Robloxs afsnit om bevægelsestjek beskriver.

Trin 6: test på hver enhed

  1. Tryk på Play, og hold Shift nede, mens du går. Hastigheden stiger fra 16 til 26 studs i sekundet, og den grønne bjælke nederst på skærmen bliver mindre. Efter cirka 5 sekunder er den tom, og du går igen.
  2. Slip Shift. Efter 1 sekund begynder bjælken at fylde op. Indtil den er en femtedel fuld, gør Shift ingenting.
  3. Tryk på Q, mens du går: du suser et stykke fremad, og en fjerdedel af bjælken er væk. Tryk på Q igen med det samme, og der sker ingenting, før der er gået et sekund. Hvis dashen føles for kort eller for lang, så ændr DASH_SPEED eller DASH_SECONDS i MovementConfig.
  4. Hop, og tryk derefter på hop igen i luften for et andet hop. Land, og prøv igen: hvert hop fra jorden giver hoppet i luften tilbage.
  5. Hold Space nede gennem hele hoppet. Det skal give ét hop, ikke to, fordi hoppet i luften kræver et nyt tryk.
  6. Slå Device Simulator til i Studio (i skrivende stund en beta: File, Beta Features, New Device Simulator, og genstart derefter Studio), eller slå den gamle Device Emulator til i menuen Test. Vælg en telefon, og tryk på Play. Knapperne Sprint og Dash dukker op. Hold Sprint, mens du styrer, hold derefter hopknappen nede gennem hele hoppet, og tjek, at der kun er ét hop.
  7. Åbn Controller Emulator (Controller på fanen Emulation eller Virtual controller i Device Simulator-panelet). Hold L3 under bevægelse for at sprinte, tryk på B for en dash og på A to gange for et dobbelthop.
  8. Nulstil karakteren via spillets menu. Bjælken er fuld igen, der er ingen MovementCheck-advarsel i Output, og hvis du stadig simulerer en telefon, er knapperne Sprint og Dash på plads.
  9. Spil nu som snyder. Klik på kontakten Client/Server, indtil Explorer viser klienten, markér din karakters Humanoid i Workspace, og sæt WalkSpeed til 60 i Properties-vinduet. Gå rundt i nogle sekunder: i Output dukker en advarsel op som MovementCheck: YourName moved 60 studs/s. Sæt den tilbage til 16, sprint og lav dashes som normalt i et minut, og tjek, at Output er tavst.
  10. Hvis dit place har Workspace.PlayerScriptsUseInputActionSystem sat til Enabled, så test dobbelthoppet igen: Robloxs dokumentation siger ikke, om JumpRequest opfører sig på samme måde med den.

Hvis der slet ikke sker noget, så åbn Output-vinduet via menuen Window i Studio, og led efter en rød fejl fra MovementClient, eller kig i almindelige fejl.

Hvor hurtigt og hvor længe: presets efter spiltype

Den rigtige sprint afhænger af spillet. En jagt i et horrorspil har brug for en kort, langsom sprint, der slutter på det værst tænkelige tidspunkt; et stort åbent kort har brug for en lang, så spillerne ikke keder sig på vej over det. Disse presets bruger de samme scripts og ændrer kun ganghastigheden og MovementConfig. Det er vores udgangspunkter, beregnet ud fra indstillingerne, ikke målt på spillere.

Ganghastighed, sprint og stamina efter spiltype. Sprinttid er MAX_STAMINA / DRAIN_PER_SECOND; genopfyldning er MAX_STAMINA / REGEN_PER_SECOND plus 1 sekunds REGEN_DELAY
SpiltypeCharacterWalkSpeedSPRINT_BONUS (sprinthastighed)DRAIN_PER_SECONDREGEN_PER_SECONDFuld sprintFra tom til fuldAfstand på én bjælke
Denne guide1610 (26)20155 s7.7 s130 studs
Jagt i horror128 (20)25104 s11 s80 studs
Battlegrounds og kamp1612 (28)15206.7 s6 somkring 187 studs
Åben verden eller simulator1616 (32)102510 s5 s320 studs
Obby eller parkour168 (24)ingen stamina: brug ShiftToSprint
  • Ganghastigheden sættes i StarterPlayer. Markér StarterPlayer, og sæt CharacterWalkSpeed (standard 16). Hver ny karakter starter med den hastighed, sprint lægger SPRINT_BONUS til, og MovementCheck læser den også, så tjekket på serveren følger dit valg.
  • MovementCheck tilpasser sig. Det tillader ganghastigheden plus sprintbonussen og en fjerdedel mere til lag: 25 studs i sekundet for horror-presettet, 40 for åben verden. Intet andet skal ændres.
  • I et obby ændrer sprint banen. Med hurtigere sprint kan længere huller springes over. Byg hoppene, og tjek derefter hvert ved sprinthastighed, ellers gør sprinten etaperne for lette. Guiden til obby-checkpoints passer godt sammen med ShiftToSprint.
  • I horror er dræberen målestokken. Gør forfølgeren lidt hurtigere end ganghastigheden og lidt langsommere end sprint, så flugten afhænger af, hvornår bjælken løber tør. Guiden til horrorspil gennemgår resten af løkken.

Hvad der er galt med gamle sprint-scripts

Gamle tutorials til sprint, dash og dobbelthop virker ofte stadig, men mange bruger tricks, som Roblox siden har erstattet, eller ødelægger andre systemer i dit spil. Hvis du retter et kopieret script, så sammenlign det med denne liste.

Tricks fra gamle tutorials, og hvad denne guide gør i stedet
TrickHvad problemet erDenne guide
BodyVelocity til dashForældet: Roblox siger, at man skal bruge LinearVelocity i stedetLinearVelocity i Plane-tilstand
Løkke på RunService.RenderSteppedTil nyt arbejde er den erstattet af PreRender. Spillogik som stamina hører hjemme på Heartbeat, som Roblox beskriver til periodiske opgaver som genopfyldning af livHeartbeat med deltaTime
Stamina-løkke med wait()wait() er forældet til fordel for task.wait() og bliver bremset, så den kan vente længere end bedt om, og et fast forbrug pr. wait bruger stamina ujævntForbrug og genopfyldning hvert frame med deltaTime
UserInputService.InputBegan uden tjek af chattenEt tryk på Shift, mens man skriver en besked i chatten, starter sprintContextActionService, som også tilføjer en knap på telefonen
WalkSpeed = 16 ved slip eller hvert frameOverskriver enhver anden hastighed, for eksempel en gamepass-fordelÆndrer kun WalkSpeed ved sprintens start og slutning og lægger til den nuværende værdi
Sprint via RemoteEvent, så serveren sætter WalkSpeedExploitere sætter alligevel selv deres WalkSpeed, og sprinten starter med en forsinkelse på turen frem og tilbageSprint på klienten plus afstandstjek på serveren
Dobbelthop ved hver JumpRequestJumpRequest udløses flere gange for én hopforespørgsel, og en holdt knap kan blive ved med at bede om hopPause på 0.25 sekund og tjek af nyt tryk
UserInputService.TouchEnabled som tjek af "det er en telefon"Den er true på bærbare med touchskærmContextActionService tilføjer knapper på skærmen på touchenheder uden dit eget enhedstjek
Humanoid:LoadAnimation til sprintanimationForældet til fordel for Animator:LoadAnimationSprintanimation nedenfor bruger Animator

Robloxs nye måde: Input Action System

Robloxs side om Input Action System tager karakterens sprint som første eksempel. I stedet for kald til BindAction sættes styringen op i Studio: en InputAction med navnet CharacterSprint inde i en input context i ReplicatedStorage, med én InputBinding til Left Shift, én til knappen Y på gamepad og én knyttet til en knap på skærmen, som du tegner i StarterGui. Derefter lytter et klient-script efter handlingens events Pressed og Released, fordobler WalkSpeed ved tryk og sætter den tilbage ved slip.

Det er værd at skifte til den, hvis du vil lægge styringen ud i Studio i stedet for i koden, have din egen touchknap i stedet for ContextActionServices knap eller have kontekster, der skifter hele sæt af styring, for eksempel til menuer eller køretøjer. Siden anbefaler også at sætte Workspace.PlayerScriptsUseInputActionSystem til Enabled, og server authority kræver det.

Stamina-løkken og dashen fra denne guide virker på samme måde med Input Action System alene (uden server authority). Behold MovementConfig, Heartbeat-løkken og dash(), slet de to kald til BindAction og deres handlere, og forbind handlingerne i stedet: Pressed på sprint-handlingen sætter sprintHeld til true, og dens Released til false, og Pressed på dash-handlingen kalder dash(). Bliv ved med at finde Humanoid hvert frame, som MovementClient gør, fordi eksemplet i dokumentationen gemmer den første karakters Humanoid, og efter en respawn er den væk.

Roblox tester også Character Controller Library, en beta, der slås til under Beta Features og Avatar Settings i Studio. Dens side om egne evner bygger som eksempel en dash med et aktivt vindue på 0.2 sekund og en cooldown på 1 sekund, altså med samme timing som dashen fra denne guide.

Sådan udvider du: animation, kamera og et sprint-pass

Sprintanimation

Lav en løbeanimation i Animation Editor, giv den prioriteten Movement (Roblox anbefaler den til gå- og løbeanimationer), udgiv den, og kopiér asset-ID. I MovementClient opretter du en Animation med det AnimationId, indlæser den med Animator:LoadAnimation ved hjælp af Animator inde i karakterens Humanoid, starter sporet der, hvor sprinten starter, og stopper det der, hvor den slutter. Indlæs den igen for hver ny karakter.

Animationer, som din enhed starter på din karakter, kan ses af alle, hvis du bruger den Animator, Roblox har lagt der: spor, der er indlæst på en Animator oprettet af et LocalScript, replikeres ikke. Humanoid:LoadAnimation, som mange gamle tutorials bruger, er forældet.

Bredere kamera under sprint

En lidt bredere synsvinkel får sprinten til at føles hurtigere. De samme to steder tweener du workspace.CurrentCamera.FieldOfView fra standardværdien 70 til cirka 80, når sprinten starter, og tilbage, når den slutter, for eksempel med TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox begrænser værdien til mellem 1 og 120 og advarer om, at meget lave eller meget høje værdier kan desorientere spillerne. Hvis et andet script i spillet også ændrer synsvinklen, så tween tilbage til den fundne værdi i stedet for til 70.

Hurtig sprint som gamepass

Gamepass-guiden virker allerede med dette script: dens Speed-fordel på serveren sætter WalkSpeed til 24 for hver ny karakter, MovementClient lægger sprintbonussen oveni, og 34 studs i sekundet holder sig inden for det, MovementCheck tillader.

Til et pass, der gør selve sprinten hurtigere, tilføjer du passet FastSprint i PassConfig.ids fra den guide. Dens server-script sætter så attributten OwnsPass_FastSprint på spilleren, så snart købet er bekræftet. I MovementClient bruger du en større bonus end Config.SPRINT_BONUS, når player:GetAttribute("OwnsPass_FastSprint") == true. I MovementCheck giver du sådanne spillere en større tolerance ved at læse den samme attribut på serveren, hvor spilleren ikke kan ændre den, og tjekker, at den nye maksimale hastighed holder sig under det, tjekket markerer.

Én begrænsning, der er god at kende: hvis et andet script ændrer WalkSpeed midt i en sprint, sætter slutningen af den sprint hastigheden tilbage til den, der var før. Den næste respawn sætter passets hastighed igen, fordi gamepass-scriptet anvender den på hver ny karakter.

Almindelige fejl og løsninger

Åbn Output-vinduet (menuen Window, derefter Output), før du trykker på Play. De fleste problemer med disse scripts skriver en fejl eller en advarsel der med scriptets navn og linjenummer.

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

MovementClient eller MovementCheck venter på et modul, der ikke findes under præcis det navn. Det skal være et ModuleScript med navnet MovementConfig direkte inde i ReplicatedStorage. Guiden til script-fejl gennemgår denne advarsel i detaljer.

Shift gør ingenting

Tjek, at ShiftToSprint eller MovementClient er et LocalScript og ikke et Script, og at det ligger i StarterPlayerScripts. Med MovementClient skal karakteren også gå og have mindst 20 stamina for at starte en sprint, så hold Shift nede, mens du bevæger dig. Hvis Shift Lock skifter i stedet for sprint, så se spørgsmålet om Shift Lock nedenfor.

Sprinten stopper efter nogle sekunder

Det er staminaen, der løber tør: 100 stamina med 20 i sekundet rækker til 5 sekunder. Hæv MAX_STAMINA, eller sænk DRAIN_PER_SECOND i MovementConfig.

Dashen gør ingenting

Dashen kræver 25 stamina, venter 1 sekund efter den forrige og gør ingenting, mens du sidder. Hvis det ikke er det, har din karakters rodpart måske ingen Attachment med navnet RootAttachment, det sker med nogle egne karakterer: tilføj den til HumanoidRootPart i din StarterCharacter.

Dobbelthoppet virker ikke

DoubleJump skal være et LocalScript i StarterCharacterScripts, ikke i StarterPlayerScripts, fordi det læser script.Parent som karakteren. Tryk på hop en gang til, efter at du har forladt jorden: en holdt knap tæller ikke som et nyt tryk, og at gå ud over en kant giver intet hop i luften.

Der er ingen Sprint- eller Dash-knap på telefonen

ContextActionService tilføjer kun sine knapper på touchenheder, så på en PC uden touchskærm ses de aldrig. Test med en telefon i Device Simulator i Studio (det er en beta: slå New Device Simulator til under File, Beta Features, og genstart Studio). BindAction kan højst oprette 7 touchknapper, så tæl, hvor mange andre scripts i spillet laver.

MovementCheck klager over ærlige spillere

De almindelige årsager: en teleport fra et andet server-script, et transportbånd eller et køretøj, eller lag. Sæt attributten MovementCheckSkip efter dine teleporter (se Respawns og teleporter), og hæv SPEED_ALLOWANCE, hvis tjekket stadig udløses i almindeligt spil.

Hastighedsforøgelsen forsvinder efter sprint

Et andet script ændrede WalkSpeed under sprinten, og da sprinten sluttede, satte den hastigheden tilbage til den, den så ved starten. Giv forøgelser, når karakteren spawner, som gamepass-guiden gør, så en respawn sætter den rigtige hastighed igen.

Lav det med RoCode

Hvis du ikke har lyst til at sætte alt det her op i hånden, kan RoCode bygge det i det place, du har åbent. RoCode er en uafhængig AI-agent til Roblox Studio, ikke fra Roblox: du beskriver ændringen i webchatten, og dens Studio-plugin opretter scripts i din Explorer, så du ikke behøver at indsætte kode.

Du skriver

Tilføj sprint med Shift og en stamina-bjælke: ganghastighed plus 10, mens Shift holdes nede, 100 stamina, forbrug 20 i sekundet, genopfyldning 15 i sekundet efter et sekunds hvile, en Sprint-knap på telefoner, dash på Q og dobbelthop.

RoCode gør
  • Kan først gennemse dit place med Search Scripts og Read Script for at finde andre scripts, der ændrer WalkSpeed (for eksempel en gamepass-fordel), så sprinten lægges oven i dem
  • Skriver ModuleScript, LocalScripts og tjekket på serveren med Create Script
  • Den er instrueret i at tjekke kompileringen af hvert script, den skriver, med Check Script, som kompilerer det i Studio uden at køre det
  • Sætter et fortrydelsespunkt før og efter hver pakke ændringer, så Ctrl+Z ruller én pakke tilbage ad gangen

RoCode kan ikke lave en løbeanimation: lav den i Animation Editor, og indsæt dens ID. Med plugin 3.9.11 eller nyere kan RoCode køre en playtest af dit spil i Studio og styre en testfigur for at tjekke, at alt virker, og med plugin 3.9.15 eller nyere kan testfiguren trykke på taster, for eksempel holde Shift og tjekke, at WalkSpeed steg. Den bestemmer selv, hvornår der køres en playtest, op til 2 pr. build plus 1 for at tjekke sin rettelse, og tjekker kun det, den selv har besluttet at teste, så prøv selv sprint, dash og dobbelthop, og tjek knapperne på telefonen i Device Simulator i Studio. Bevægelse er ét system blandt mange i et spil; at lave et helt spil med RoCode foregår ét system pr. prompt, som her. Sådan forbinder RoCode til Studio.

Ofte stillede spørgsmål

Hvorfor virker sprint-scriptet ikke på telefonen?

En telefon har ingen Shift-tast. Bind sprint med ContextActionService:BindAction, og send true som tredje argument: det tilføjer en knap på skærmen på touchenheder, som både ShiftToSprint og MovementClient gør.

Skal sprint laves på serveren?

Nej. Hver enhed flytter sin egen karakter, så en WalkSpeed sat af serveren stopper ikke en snyder, der kan sætte sin egen, og den nye hastighed kommer først efter turen frem og tilbage, så sprinten starter med forsinkelse. Lav sprint på klienten, og tjek på serveren, hvor langt karaktererne faktisk flytter sig, som i trin 5. Robloxs beta server authority fungerer anderledes, og bevægelseskoden skal skrives om til den.

Hvorfor bliver karakteren ved med at sprinte, når jeg har sluppet Shift?

Scriptet missede slippet, som regel fordi det kun lytter efter trykket. ContextActionService sender End, når tasten slippes, og Cancel, når en anden binding overtager den; MovementClient stopper ved begge og også, når staminaen løber tør, eller karakteren holder op med at bevæge sig.

Hvordan tilføjer jeg en sprintanimation?

Indlæs en løbeanimation via Animator i karakterens Humanoid i det samme LocalScript, start den, når sprinten starter, og stop den, når den slutter. Giv den prioriteten Movement. Animationer, der startes på din egen karakter, kan ses af alle.

Hvorfor udløses dobbelthoppet af sig selv på telefonen?

En holdt hopknap på telefonen bliver ved med at bede om hop. Regn kun et hop som nyt, hvis forespørgslerne et øjeblik er holdt op, som scriptet DoubleJump gør.

Hvad er standardganghastigheden i Roblox?

16 studs i sekundet. Den kommer fra StarterPlayer.CharacterWalkSpeed, som sætter Humanoid.WalkSpeed for hver ny karakter. Sprinten fra denne guide lægger 10 til, så sprint går med 26.

Hvor hurtig skal en sprint være i Roblox?

De fleste spil lægger mellem en halv og en hel ganghastighed til: 16 bliver til noget mellem 24 og 32. En kort, langsom sprint passer til horror, og en lang, hurtig til store kort. Presets efter spiltype giver ganghastighed, sprintbonus og stamina-tal for hver.

Hvordan laver jeg sprint med stamina?

Gem et stamina-tal på spillerens enhed, brug af det hvert frame under sprint, og fyld det op efter en kort hvile, begge gange med hensyn til frametiden, og stop sprinten, når det når 0. MovementClient fra trin 3 gør det med en bjælke på skærmen; tallene ligger i MovementConfig.

Hvordan sprinter man med controller i Roblox?

Bind gamepaddens ButtonL3 (tryk på venstre stick) med ContextActionService sammen med Left Shift, som begge scripts her gør. ShiftToSprint gør L3 til en kontakt, fordi det er trættende at holde sticken trykket ind og samtidig styre med den.

Konflikter sprint med Shift med Shift Lock?

Det kan den. Spillere, der har slået Shift Lock til i Roblox-indstillingerne, skifter den med Shift-tasten, så én tast gør to ting. I Robloxs dokumentation står der, at Shift Lock-API'erne udfases. Hvis konflikten generer dine spillere, så slå StarterPlayer.EnableMouseLockOption fra, eller bind sprint i MovementClient til en anden tast, for eksempel Left Ctrl.

Kilder og videre læsning

Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.

Prøv RoCode i dit eget spil.

Gratis credits hver dag, intet kort. Installér pluginet, beskriv en funktion, og se hvad der dukker op i Studio.