Veiledning · Spillsystemer

Slik lager du sprint med Shift i Roblox Studio for PC, mobil og konsoll

Sprint med Shift i Roblox handler om ett tall: WalkSpeed på Humanoid, som øker mens Shift holdes nede. Steg 1 gjør nøyaktig det i ett kort LocalScript som også virker med Sprint-knappen på mobilen og med gamepad. Resten av guiden legger til det et større spill trenger: en stamina-bar, en dash med moderne fysikk, et dobbelthopp som ikke utløses av en knapp som holdes inne, og en forståelse av hva serveren kan sjekke og hva den ikke kan.

Oppdatert 20. november 202625 min lesingSkrevet av

Kort fortalt

Legg ett LocalScript i StarterPlayerScripts som binder handlingen Sprint med ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Mens Shift holdes nede, legger du 10 til Humanoid.WalkSpeed (16 blir 26), og når den slippes, setter du tilbake den forrige verdien. Argumentet true legger til en Sprint-knapp på berøringsskjermer, og i skriptet fra denne guiden slår den knappen og L3 på gamepad sprint av og på i stedet for å virke mens de holdes inne.

  • Legg til på den nåværende WalkSpeed i stedet for å sette 26, så en hastighetsøkning fra et gamepass beholdes.
  • Sprint kjører på spillerens enhet. Serveren kan ikke håndheve WalkSpeed; den kan bare måle hvor langt karakterene flytter seg, og flagge hastigheter som sprint ikke kan forklare.
  • En stamina-bar, en dash og et dobbelthopp etter samme idé legges til i steg 2 til 4. Hvor raskt og hvor lenge det skal sprintes, får du hjelp med i presets etter spilltype, med tall for horror, kamp og åpen verden.
På denne siden
  1. Slik virker det
  2. 1. Sprint med Shift
  3. 2. Innstillingsmodul
  4. 3. Sprint og dash
  5. 4. Dobbelthopp
  6. 5. Sjekk på serveren
  7. 6. Test
  8. Hastighets-presets
  9. Gamle skript
  10. Input Action System
  11. Utvidelser
  12. Common errors
  13. Med RoCode
  14. Ofte stilte spørsmål
  15. Kilder og videre lesing

Slik virker sprint i Roblox

IllustrasjonShift gir sprint med WalkSpeed 26 mens baren synker, Q gjør en dash for en fjerdedel av baren, og et nytt trykk på hopp i luften hopper igjen.

Hver spillers enhet flytter spillerens egen karakter. Tastaturet, kontrolleren eller berøringsskjermen bestemmer hvor karakteren går, og Roblox sender resultatet til serveren og til alle andre. Derfor er sprint et LocalScript som øker Humanoid.WalkSpeed mens en tast holdes nede, og det er alt steg 1 gjør. Resten av guiden er det et større spill trenger rundt det: en stamina-bar, en dash, et dobbelthopp og en sjekk på serveren mot juksere.

Hva bevegelsessystemet består av
ElementHvor det liggerHva det gjør
LocalScript ShiftToSprintStarterPlayerScriptsSteg 1 alene: sprint på tastatur, mobil og gamepad, uten stamina. Når du legger til stamina og dash, erstattes det av MovementClient.
ModuleScript MovementConfigReplicatedStorageTallene: sprintbonus, stamina og dash. Både LocalScriptet og sjekken på serveren leser dem.
LocalScript MovementClientStarterPlayerScriptsBinder Sprint og Dash til en tast, en gamepad-knapp og en berøringsknapp, kjører stamina-løkken, tegner baren og utfører dashen.
LocalScript DoubleJumpStarterCharacterScriptsGir ett ekstra hopp i luften. En ny kopi starter i hver ny karakter.
Script MovementCheckServerScriptServiceMåler hvor langt hver karakter faktisk flytter seg, og skriver en advarsel i Output når noen over tid beveger seg raskere enn sprint og dash tillater.
Explorer når bevegelsessystemet er ferdig
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Hvis forskjellen mellom Script og LocalScript er ny for deg, forklarer Script, LocalScript og ModuleScript hvor hver type kjører og hvorfor.

Steg 1: sprint med Shift i ett LocalScript

Hvis du bare trenger raskere løping mens Shift holdes nede, er dette ene skriptet nok. Det gir også mobiler en Sprint-knapp på skjermen og lar deg sprinte med venstre stikke på en gamepad.

  1. I Explorer folder du ut StarterPlayer, holder musen over StarterPlayerScripts, klikker på knappen + og setter inn et LocalScript med navnet ShiftToSprint.
  2. Erstatt innholdet med koden nedenfor, og trykk på Play.
LocalScript i StarterPlayerScripts med navnet ShiftToSprint
-- LocalScript i StarterPlayer > StarterPlayerScripts med navnet ShiftToSprint.
-- Hold Left Shift nede for å sprinte. På en gamepad trykker du på venstre stikke (L3) for å
-- slå sprint av eller på. På en mobil trykker du på Sprint-knappen for å slå den av eller på.

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

-- Innstillinger
local SPRINT_BONUS = 10 -- legges til WalkSpeed under sprint (16 blir 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: knappen må holdes nede

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- den WalkSpeed som det skal vendes tilbake 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 nåværende hastigheten og legg til på den, så en økning fra et annet skript beholdes
		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
		-- Veksle: hvert trykk slår sprint av eller på
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Ett kall binder tasten, gamepad-knappen og, på berøringsskjermer, en knapp på skjermen
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

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

Endre SPRINT_BONUS for å gjøre sprinten raskere eller saktere. Sett TOGGLE_ON_TOUCH_AND_GAMEPAD til false, så knappen på mobilen og L3 virker som Shift: sprint bare mens de holdes nede.

BindAction binder én handling til Left Shift og til L3-knappen på gamepad, og det tredje argumentet, true, legger til en knapp på berøringsskjermer; SetTitle skriver "Sprint" på den. Handleren får også selve inputen, så den kan skille et trykk på tastaturet fra en gamepad eller en berøringsknapp. Når sprinten starter, husker skriptet den nåværende WalkSpeed og legger til SPRINT_BONUS; når den slutter, setter det tilbake den lagrede verdien. En hastighet som et annet skript har satt, for eksempel Speed-fordelen fra gamepass-guiden, beholdes. En ny karakter starter med den normale WalkSpeed, så CharacterAdded-handleren nullstiller bare flagget.

Hold eller veksle?

Slik virker ShiftToSprint på hver enhet når TOGGLE_ON_TOUCH_AND_GAMEPAD er true
Enhet og inputVirker somHvorfor
Tastatur: Left ShiftHoldDet er lett å holde tasten nede mens man beveger seg, og når den slippes, stopper sprinten med en gang.
Gamepad: trykk på venstre stikke (L3)VeksleDet er slitsomt å holde stikken inne og samtidig styre med den.
Mobil eller nettbrett: Sprint-knappen på skjermenVeksleEn tommel som holder knappen, kan ikke samtidig trykke på Jump.

For å teste trykker du på Play og holder Shift nede mens du går: hastigheten øker fra 16 til 26 studs i sekundet, og hvis du slipper, senker du farten. For mobil velger du en telefon i Device Simulator i Studio, trykker på Play og trykker på Sprint én gang for å starte og én gang til for å stoppe. For gamepad åpner du Controller Emulator under en playtest og trykker på L3. Hele listen over sjekker per enhet finnes i steg 6.

Steg 2 og 3 erstatter dette skriptet med et annet med stamina-bar og dash. Steg 4 og 5 legger til dobbelthopp og sjekken på serveren og virker med begge skriptene.

Steg 2: tallene for stamina og dash i én modul

For en sprint som går tom, bytter steg 2 og 3 ut ShiftToSprint med et større LocalScript med stamina-bar og dash. Slett ShiftToSprint først: begge skriptene binder handlingen Sprint.

Alle tallene ligger i ett ModuleScript, så følelsen av bevegelsen justeres på ett sted. MovementClient leser dem på hver spillers enhet, og MovementCheck leser den samme modulen på serveren for å vite hvor rask sprint og dash skal være.

  1. I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og setter inn et ModuleScript.
  2. Gi det nytt navn til MovementConfig, og erstatt innholdet med koden nedenfor.
ModuleScript i ReplicatedStorage med navnet MovementConfig
-- Ett sett tall for bevegelses-LocalScriptet og hastighetssjekken på serveren.

local MovementConfig = {
	SPRINT_BONUS = 10, -- legges til den nåværende WalkSpeed: 16 (Robloxs standard) blir 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 sekunders sprint fra en full bar
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- sekunder etter at sprinten slutter, før stamina begynner å komme tilbake
	MIN_TO_START = 20, -- stamina som kreves for å starte en sprint, så en tom bar ikke blinker

	DASH_SPEED = 60, -- studs i sekundet under en dash
	DASH_SECONDS = 0.2, -- da dekker en dash omtrent 12 studs
	DASH_COST = 25, -- stamina
	DASH_COOLDOWN = 1,
}

return MovementConfig
Hva hver innstilling gjør
InnstillingVerdiEffekt
SPRINT_BONUS10Legges til WalkSpeed under sprint. WalkSpeed i Roblox er 16 som standard, så sprint går med 26 studs i sekundet.
MAX_STAMINA100En full bar.
DRAIN_PER_SECOND20En full bar holder til 5 sekunders sprint.
REGEN_PER_SECOND15En tom bar fylles opp på omtrent 6.7 sekunder.
REGEN_DELAY1Sekunder med hvile før stamina begynner å komme tilbake.
MIN_TO_START20Stamina som kreves for å starte en sprint.
DASH_SPEED60Studs i sekundet under en dash.
DASH_SECONDS0.2Hvor lenge en dash varer: omtrent 12 studs ved 60 studs i sekundet.
DASH_COST25Stamina per dash.
DASH_COOLDOWN1Sekunder mellom dasher.

Hver side kjører sin egen kopi av modulen (en modul kjøres én gang på hver side), så en spiller som endrer disse tallene på sin enhet, endrer bare sin egen kopi. Men her beskytter det ingenting: spillerens enhet flytter uansett karakteren og kan gi seg selv uendelig stamina, uansett hva som står i modulen. Sjekken på serveren i steg 5 er bygget med det i tankene.

Steg 3: sprint med stamina og dash

Dette LocalScriptet lager det spillerne merker. Det binder Sprint og Dash, tegner stamina-baren, kjører stamina-løkken hver frame og utfører dashen.

  1. I Explorer folder du ut StarterPlayer, holder musen over StarterPlayerScripts og setter inn et LocalScript med navnet MovementClient.
  2. Erstatt innholdet med koden nedenfor.
LocalScript i StarterPlayerScripts med navnet MovementClient
-- Hold Shift (eller L3, eller Sprint-knappen på mobilen) nede for å sprinte så lenge det er stamina.
-- Trykk på Q (eller B, eller Dash-knappen) for å gjøre en dash i bevegelsesretningen.

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 som det skal vendes tilbake til når sprinten slutter
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Stamina-baren: en ramme med en fylling der bredden svarer til gjenværende 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 bare et flagg; Heartbeat-løkken nedenfor avgjør hver frame om det skal sprintes
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Bare trykk og slipp endrer det: en finger som glir over berøringsknappen, 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 sitter: en sittende karakter er sveiset til setet, så den ville dytte hele kjøretøyet
	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 -- sett påfyllingen på pause, slik sprint gjør

	-- Dash dit spilleren beveger seg, eller dit den ser 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-modus holder den vannrette hastigheten og lar 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 kall binder en tast, en gamepad-knapp og, på berøringsenheter, en knapp på skjermen
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")

-- Hver frame: bruk stamina under sprint og bevegelse, fyll opp etter 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

	-- Endre WalkSpeed bare når sprinten starter og slutter, så en hastighet som et annet
	-- skript har satt (for eksempel et speed-pass), beholdes, og sprinten legges oppå 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 full stamina, og ingenting holdes nede
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- en ny Humanoid starter med den normale WalkSpeed
end)

Stamina-baren lages i koden med ResetOnSpawn satt til false, så den blir på skjermen etter respawn, og CharacterAdded-handleren nederst fyller den opp igjen for hver ny karakter. Linjene med type Config beskriver hva modulen returnerer, så streng typesjekk fanger en skrivefeil i et innstillingsnavn; under spillet endrer de ingenting.

Tastatur, gamepad og knapp på mobilen med ett kall

ContextActionService:BindAction tar navnet på handlingen, en handlerfunksjon, om det skal lages en berøringsknapp, og deretter inputene. Hvis du sender true som tredje argument, legger ContextActionService til en knapp på skjermen på berøringsenheter, inne i en ScreenGui med navnet ContextActionGui i spillerens PlayerGui. SetTitle skriver "Sprint" og "Dash" på knappene. BindAction kan lage høyst 7 berøringsknapper, så følg med på antallet hvis andre skript i spillet også bruker dem.

Handleren får tilstanden til inputen: Begin ved trykk og End ved slipp. onSprint husker bare om Sprint holdes nede. Den regner også Cancel som et slipp, som ContextActionService sender når en annen binding tar over inputen, og ignorerer Change, som en finger som beveger seg over berøringsknappen kan sende. Begge handlerne returnerer Pass, så neste binding på samme tast også får inputen.

Roblox-referansen for ContextActionService anbefaler den fremfor UserInputService.InputBegan i de fleste tilfeller. Eksempelet deres: et bilhorn på H som ikke skal tute mens spilleren skriver i chatten. En binding utløses bare så lenge den er den nyeste for den inputen, så når chatten tar over tastaturet, trenger du ikke sjekke noe. Gamepad-inputer: ButtonL3 (trykk på venstre stikke, som holdes under bevegelse) og ButtonB. Robloxs eget sprint-eksempel bruker ButtonY, så bytt KeyCode i BindAction hvis det passer bedre til spillet ditt.

Stamina-løkken

RunService.Heartbeat utløses hver frame etter fysikksteget og sender deltaTime, antall sekunder siden forrige frame. Hvis du ganger forbruks- og påfyllingshastigheten med den, holder en full bar til 5 sekunder, uansett om spillet kjører med 30 eller 240 frames i sekundet.

Hver frame avgjør løkken om karakteren skal sprinte: Sprint holdes nede, karakteren går (Humanoid.MoveDirection er nullvektoren når den står stille), og det er fortsatt stamina igjen. For å starte en sprint kreves minst MIN_TO_START (20); for å fortsette er alt over 0 nok. Uten denne marginen ville en tom bar som fylles en liten bit hver frame, slå sprint av og på hver frame. Påfyllingen starter REGEN_DELAY (1 sekund) etter siste sprint eller dash, så når spilleren har tømt baren, venter den omtrent 2.3 sekunder før den kan sprinte igjen.

WalkSpeed endres bare i den framen der sprinten starter eller slutter. Ved start husker skriptet den nåværende WalkSpeed og legger til SPRINT_BONUS; ved slutt setter det tilbake den lagrede verdien. Derfor beholdes en hastighet som et annet skript har satt: Speed-fordelen fra gamepass-guiden setter WalkSpeed til 24, og med dette skriptet sprinter eierne med 34. Et skript som skriver WalkSpeed = 16 hver frame eller ved hvert slipp, ville i det stille oppheve den fordelen.

Dash

En dash dytter karakteren dit den beveger seg, eller dit den ser hvis den står stille, og retningen gjøres vannrett, så den aldri peker opp eller ned. Den koster 25 stamina, setter påfyllingen på pause slik som sprint og har en cooldown på 1 sekund. Den sjekker ikke etter bakke, så den virker også i luften, noe som passer godt med dobbelthopp. Mens karakteren sitter, gjør dashen ingenting: en sittende karakter er sveiset til setet, og i et kjøretøy kunne dyttet flytte hele kjøretøyet.

Dyttet er en LinearVelocity-constraint på rotpartens RootAttachment. I Plane-modus med aksene X og Z holder den en vannrett hastighet på 60 studs i sekundet og rører ikke den loddrette, så tyngdekraften virker, og en dash utfor en kant faller som vanlig. MaxForce er math.huge, så dyttet er ubegrenset. Debris:AddItem ødelegger constrainten etter DASH_SECONDS uten at skriptet må vente, så dashen varer 0.2 sekund, omtrent 12 studs ved den hastigheten.

Gamle veiledninger bruker BodyVelocity, som Roblox har merket som utdatert med beskjed om å bruke LinearVelocity i stedet. Trikset med MaxForce på null langs én akse erstattes av modusene Line, Plane og Vector på LinearVelocity. Siden spillerens enhet selv simulerer karakteren sin, flytter en constraint som et LocalScript har laget, karakteren, og andre spillere ser dashen som enhver annen bevegelse.

Robloxs egen UI-veiledning fester constrainten til humanoid.RootPart.RootAttachment på nøyaktig samme måte. Hvis spillet ditt har en egen karakter der rotparten ikke har en Attachment med navnet RootAttachment, gjør dashen ingenting: legg den til i HumanoidRootPart i din StarterCharacter.

Steg 4: dobbelthopp

Dobbelthoppet bor i sitt eget LocalScript i StarterCharacterScripts. Roblox legger en kopi av skriptene fra den containeren i hver karakter ved spawn, og de kopiene overlever ikke respawn, så hvert liv starter med et ferskt skript, og ingenting overføres fra det forrige.

  1. I Explorer folder du ut StarterPlayer, holder musen over StarterCharacterScripts og setter inn et LocalScript med navnet DoubleJump.
  2. Erstatt innholdet med koden nedenfor.
LocalScript i StarterCharacterScripts med navnet DoubleJump
-- Gir ett ekstra hopp i luften. Starter på nytt for hver ny karakter,
-- så ingenting overføres etter 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 utløses flere ganger for ett trykk
local NEW_PRESS_GAP = 0.1 -- en hoppknapp som holdes inne, fortsetter å sende JumpRequest; en pause av denne lengden betyr 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 hopp fra bakken (ikke et av våre hopp i luften) gir hopp i luften tilbake
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest utløses når spilleren ber om et hopp, for eksempel med Space eller hoppknappen på mobilen
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Bare et nytt trykk hopper igjen, så en knapp som holdes inne ikke bruker opp 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)

Sett EXTRA_JUMPS til 2 for et trippelhopp.

Skriptet følger karakterens tilstand via Humanoid.StateChanged. Et bytte til Jumping som ikke kom fra Freefall, er et hopp fra bakken, så det gir et hopp i luften, og Landed tar det tilbake. Hvis man går utfor en kant, havner karakteren i Freefall uten hopp, så den får ikke noe hopp i luften. Hvis du også vil ha det der, sett jumpsLeft også ved bytte til Freefall fra enhver tilstand unntatt Jumping.

UserInputService.JumpRequest utløses når spilleren ber om et hopp, for eksempel med Space eller hoppknappen på mobilen. Roblox-referansen advarer om at den utløses flere ganger for én hoppforespørsel, og anbefaler debounce, så skriptet ignorerer forespørsler i 0.25 sekund etter siste hopp. En hoppknapp som holdes inne, kan også fortsette å be om hopp og ville bruke opp hoppet i luften i samme øyeblikk som karakteren letter fra bakken, så en forespørsel teller bare som et nytt trykk etter 0.1 sekund uten forespørsler.

Selve hoppet i luften er Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Roblox-referansen sier at det skal kalles fra et LocalScript på enheten som har network ownership over karakteren, og som standard er det spillerens egen enhet, ikke serveren. Kodeeksempelet for ChangeState i referansen er nettopp et dobbelthopp.

Steg 5: fang speedhacks på serveren

Sprint-veiledninger stopper ofte ved klienten. Et server-Script kan ikke stole på spillerens WalkSpeed, fordi exploitere endrer den på sin enhet, men det kan se hvor karakteren deres havner. MovementCheck måler det to ganger i sekundet og skriver en advarsel i Output når noen over tid beveger seg raskere enn sprint og dash tillater. Tallene for sprint og dash leser det fra MovementConfig, så legg til den modulen fra steg 2 selv om du har beholdt ShiftToSprint.

  1. Hold musen over ServerScriptService, og sett inn et Script med navnet MovementCheck.
  2. Erstatt innholdet med koden nedenfor.
Script i ServerScriptService med navnet MovementCheck
-- Spillernes enheter flytter sine egne karakterer, så en exploiter kan sette hvilken som helst WalkSpeed.
-- Denne sjekken måler hvor langt hver karakter faktisk flytter seg, og skriver i Output
-- når noen over tid beveger seg raskere enn sprint og dash tillater. Den advarer bare:
-- lag, teleportere og transportbånd kan ligne på for høy hastighet, så juster den før du straffer noen.

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
-- Sprinthastighet pluss margin for lag. Øk den hvis du selger hastighetsøkninger.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- margin for en eller to dasher
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- hvor raskt tidligere dasher tilgis

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- rotparten som lastPosition er målt på
local excess: { [Player]: number } = {} -- studs over toleransen, tilgis gradvis

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 rotpart, og en teleport på serveren (rundestart, checkpoint)
			-- setter attributtet nedenfor: begynn å måle på nytt i stedet for å flagge hoppet
			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
				-- Bare vannrett bevegelse: å falle raskt er ikke juks
				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

Advarselen vises i Output i Studio. I det publiserte spillet havner den i serverloggen i Developer Console, som du kan lese som eier av spillet: se output i det publiserte spillet.

Hva den måler

Hvert halve sekund leser skriptet posisjonen til rotparten til hver karakter og måler hvor langt den har flyttet seg vannrett siden forrige sjekk. Høyden ignoreres, så fall og hopp teller aldri med; Robloxs råd om bevegelsessjekker foreslår den samme projeksjonen på XZ-planet for spill der man går på bakken. Toleransen er standard ganghastighet pluss sprintbonusen og en fjerdedel ekstra for lag: 32.5 studs i sekundet. Avstand utover det havner i en "lekk bøtte", en akkumulator som Robloxs dokumentasjon sier passer mange utviklere godt for korte rykk. Bøtta mister 3 studs ved hver sjekk, og skriptet advarer når den inneholder mer enn 24 studs, som er en margin på omtrent to dasher.

Hva sjekken fanger hvis man regner med tallene dens
JukserenHva MovementCheck gjør
Setter WalkSpeed til 100Advarer etter omtrent ett sekunds løping
Setter WalkSpeed til 50Advarer etter omtrent 2.5 sekunders løping
Gjør dasher på rad uten cooldown (60 studs i sekundet)Advarer etter omtrent 1.5 sekund
Teleporterer mer enn 43 studs om gangenAdvarer ved neste sjekk
Løper med opptil 38 studs i sekundet, omtrent halvannen gang sprinthastighetenIngenting: under 38.5 studs i sekundet tømmes bøtta like raskt som den fylles
Endrer sin MovementConfig for å få uendelig staminaIngenting: sprint med 26 studs i sekundet er tillatt så lenge man vil
Flyr, hopper uten begrensning eller går gjennom veggerIngenting: sjekken ignorerer høyden og ser ikke på kollisjoner

Så sjekken fanger grovt juks der en spiller er tydelig raskere enn alle andre, og slipper gjennom den forsiktige. Det er den ærlige grensen for en avstandssjekk og grunnen til at Roblox lager noe sterkere (se server authority nedenfor).

Hvorfor den bare advarer

Robloxs dokumentasjon nevner at enkle hastighetssjekker kan flagge ærlige spillere med ustabil tilkobling og slutter å fungere i spill med kjøretøy eller annen kompleks bevegelse. Lagsprang, transportbånd, kjøretøy, eksplosjoner som kaster karakterer av gårde, og dine egne teleporter kan ligne på for høy hastighet, så skriptet skriver bare en advarsel. Følg med på Output mens du og testerne dine spiller som vanlig, øk SPEED_ALLOWANCE hvis ærlige spillere snubler i den, og legg til en straff, for eksempel å sette spilleren tilbake, først når sjekken er stille i vanlig spill. Hvis eksplosjoner i spillet ditt kaster karakterer av gårde, hopp også over spillere der Humanoid ikke har mer liv.

Respawns og teleporter

En respawn lager en ny rotpart, og skriptet begynner å måle på nytt når det ser den, så å dø langt fra spawnpunktet teller aldri som for høy hastighet. Teleporter som dine egne server-skript gjør, trenger et unntak, slik Robloxs dokumentasjon sier om ethvert spill med teleporter. Etter en teleport legger du til player:SetAttribute("MovementCheckSkip", true), så begynner neste sjekk å måle fra den nye posisjonen i stedet for å flagge spranget:

Platene og menyen fra teleport-guiden og Finish-platen fra guiden til ditt første spill setter den allerede etter hver flytting.

Bare verdien fra serveren teller. Et attributt som spilleren setter på sin enhet, blir på den enheten (se hva som replikeres og hva som ikke gjør det), så en jukser kan ikke slå av sjekken med det.

Løsningen for fremtiden: server authority

Robloxs sikkerhetsdokumentasjon kaller modellen server authority, i skrivende stund i beta, den mest pålitelige måten å stoppe bevegelses-exploits på. Serveren blir kilden til sannheten, og spillernes enheter sender bare inputen sin, noe som ifølge dokumentasjonen hindrer speedhacks i å virke, fordi enheten aldri får lov til å melde posisjonen sin selv.

Overgangen er en omskriving, ikke en justering. I den modellen beregner serveren bevegelsen, så WalkSpeed eller LinearVelocity som bare et LocalScript setter, oppheves når tilstanden fra serveren kommer. I Robloxs dokumentasjon står det at hovedlogikken skal kjøre i RunService:BindToSimulation()-funksjoner i et ModuleScript som både klienten og serveren kjører. Modellen krever også noen Workspace-innstillinger, blant dem PlayerScriptsUseInputActionSystem, så styringen din flytter også over til Input Action System. Behold versjonen fra denne guiden til du har flyttet sprint, stamina og dash over i den oppbygningen. Inntil da er en avstandssjekk som denne nettopp det Robloxs avsnitt om bevegelsessjekker beskriver.

Steg 6: test på hver enhet

  1. Trykk på Play, og hold Shift nede mens du går. Hastigheten øker fra 16 til 26 studs i sekundet, og den grønne baren nederst på skjermen blir mindre. Etter omtrent 5 sekunder er den tom, og du går igjen.
  2. Slipp Shift. Etter 1 sekund begynner baren å fylles opp. Til den er en femtedel full, gjør Shift ingenting.
  3. Trykk på Q mens du går: du suser et stykke fremover, og en fjerdedel av baren er borte. Trykk på Q igjen med en gang, og ingenting skjer før det har gått ett sekund. Hvis dashen føles for kort eller for lang, endre DASH_SPEED eller DASH_SECONDS i MovementConfig.
  4. Hopp, og trykk deretter på hopp igjen i luften for et andre hopp. Land og prøv igjen: hvert hopp fra bakken gir hoppet i luften tilbake.
  5. Hold Space nede gjennom hele hoppet. Det skal gi ett hopp, ikke to, fordi hoppet i luften krever et nytt trykk.
  6. Slå på Device Simulator i Studio (i skrivende stund en beta: File, Beta Features, New Device Simulator, og start deretter Studio på nytt), eller slå på den gamle Device Emulator i menyen Test. Velg en telefon, og trykk på Play. Knappene Sprint og Dash dukker opp. Hold Sprint mens du styrer, hold deretter hoppknappen nede gjennom hele hoppet, og sjekk at det bare blir ett hopp.
  7. Åpne Controller Emulator (Controller på fanen Emulation eller Virtual controller i Device Simulator-panelet). Hold L3 under bevegelse for å sprinte, trykk på B for en dash og på A to ganger for et dobbelthopp.
  8. Tilbakestill karakteren via spillets meny. Baren er full igjen, det er ingen MovementCheck-advarsel i Output, og hvis du fortsatt simulerer en telefon, er knappene Sprint og Dash på plass.
  9. Spill nå som jukser. Klikk på bryteren Client/Server til Explorer viser klienten, marker din karakters Humanoid i Workspace, og sett WalkSpeed til 60 i Properties-vinduet. Gå rundt i noen sekunder: i Output dukker det opp en advarsel som MovementCheck: YourName moved 60 studs/s. Sett den tilbake til 16, sprint og gjør dasher som vanlig i et minutt, og sjekk at Output er stille.
  10. Hvis placen din har Workspace.PlayerScriptsUseInputActionSystem satt til Enabled, test dobbelthoppet igjen: Robloxs dokumentasjon sier ikke om JumpRequest oppfører seg på samme måte med den.

Hvis ingenting skjer i det hele tatt, åpne Output-vinduet via menyen Window i Studio og se etter en rød feil fra MovementClient, eller se i vanlige feil.

Hvor raskt og hvor lenge: presets etter spilltype

Riktig sprint avhenger av spillet. En jakt i et horrorspill trenger en kort, langsom sprint som slutter i det verst tenkelige øyeblikket; et stort åpent kart trenger en lang, så spillerne ikke kjeder seg på vei over det. Disse presetsene bruker de samme skriptene og endrer bare ganghastigheten og MovementConfig. Det er våre utgangspunkter, beregnet ut fra innstillingene, ikke målt på spillere.

Ganghastighet, sprint og stamina etter spilltype. Sprinttid er MAX_STAMINA / DRAIN_PER_SECOND; påfylling er MAX_STAMINA / REGEN_PER_SECOND pluss 1 sekunds REGEN_DELAY
SpilltypeCharacterWalkSpeedSPRINT_BONUS (sprinthastighet)DRAIN_PER_SECONDREGEN_PER_SECONDFull sprintFra tom til fullAvstand på én bar
Denne guiden1610 (26)20155 s7.7 s130 studs
Jakt i horror128 (20)25104 s11 s80 studs
Battlegrounds og kamp1612 (28)15206.7 s6 somtrent 187 studs
Åpen verden eller simulator1616 (32)102510 s5 s320 studs
Obby eller parkour168 (24)ingen stamina: bruk ShiftToSprint
  • Ganghastigheten settes i StarterPlayer. Marker StarterPlayer, og sett CharacterWalkSpeed (standard 16). Hver ny karakter starter med den hastigheten, sprint legger til SPRINT_BONUS, og MovementCheck leser den også, så sjekken på serveren følger valget ditt.
  • MovementCheck tilpasser seg. Den tillater ganghastigheten pluss sprintbonusen og en fjerdedel ekstra for lag: 25 studs i sekundet for horror-presetet, 40 for åpen verden. Ingenting annet må endres.
  • I en obby endrer sprint banen. Med raskere sprint kan lengre hull hoppes over. Bygg hoppene, og sjekk deretter hvert av dem i sprinthastighet, ellers gjør sprinten etappene for lette. Guiden til obby-checkpoints passer godt sammen med ShiftToSprint.
  • I horror er drapsmannen målestokken. Gjør forfølgeren litt raskere enn ganghastigheten og litt saktere enn sprint, så flukten avhenger av når baren går tom. Guiden til skrekkspill går gjennom resten av løkken.

Hva som er galt med gamle sprint-skript

Gamle veiledninger for sprint, dash og dobbelthopp virker ofte fortsatt, men mange bruker triks som Roblox siden har erstattet, eller ødelegger andre systemer i spillet ditt. Hvis du retter et kopiert skript, sammenlign det med denne listen.

Triks fra gamle veiledninger, og hva denne guiden gjør i stedet
TriksHva problemet erDenne guiden
BodyVelocity for dashUtdatert: Roblox sier at man skal bruke LinearVelocity i stedetLinearVelocity i Plane-modus
Løkke på RunService.RenderSteppedFor nytt arbeid er den erstattet av PreRender. Spillogikk som stamina hører hjemme på Heartbeat, som Roblox beskriver for periodiske oppgaver som påfylling av livHeartbeat med deltaTime
Stamina-løkke med wait()wait() er utdatert til fordel for task.wait() og blir strupet, så den kan vente lenger enn bedt om, og et fast forbruk per wait bruker stamina ujevntForbruk og påfylling hver frame med deltaTime
UserInputService.InputBegan uten sjekk av chattenEt trykk på Shift mens man skriver en melding i chatten, starter sprintContextActionService, som også legger til en knapp på mobilen
WalkSpeed = 16 ved slipp eller hver frameOverskriver enhver annen hastighet, for eksempel en gamepass-fordelEndrer WalkSpeed bare når sprinten starter og slutter, og legger til på den nåværende verdien
Sprint via RemoteEvent, så serveren setter WalkSpeedExploitere setter uansett sin egen WalkSpeed, og sprinten starter med en forsinkelse på turen frem og tilbakeSprint på klienten pluss avstandssjekk på serveren
Dobbelthopp ved hver JumpRequestJumpRequest utløses flere ganger for én hoppforespørsel, og en knapp som holdes inne, kan fortsette å be om hoppPause på 0.25 sekund og sjekk av nytt trykk
UserInputService.TouchEnabled som sjekk av "det er en mobil"Den er true på bærbare med berøringsskjermContextActionService legger til knapper på skjermen på berøringsenheter uten egen enhetssjekk
Humanoid:LoadAnimation for sprintanimasjonUtdatert til fordel for Animator:LoadAnimationSprintanimasjon nedenfor bruker Animator

Robloxs nye måte: Input Action System

Robloxs side om Input Action System tar karakterens sprint som første eksempel. I stedet for kall til BindAction settes styringen opp i Studio: en InputAction med navnet CharacterSprint inne i en input context i ReplicatedStorage, med én InputBinding for Left Shift, én for knappen Y på gamepad og én knyttet til en knapp på skjermen som du tegner i StarterGui. Deretter lytter et klientskript etter handlingens eventer Pressed og Released, dobler WalkSpeed ved trykk og setter den tilbake ved slipp.

Det er verdt å bytte til den hvis du vil legge styringen i Studio i stedet for i koden, ha din egen berøringsknapp i stedet for knappen til ContextActionService, eller ha kontekster som bytter hele sett med styring, for eksempel for menyer eller kjøretøy. Siden anbefaler også å sette Workspace.PlayerScriptsUseInputActionSystem til Enabled, og server authority krever det.

Stamina-løkken og dashen fra denne guiden virker på samme måte med bare Input Action System (uten server authority). Behold MovementConfig, Heartbeat-løkken og dash(), slett de to kallene til BindAction og handlerne deres, og koble til handlingene i stedet: Pressed på sprint-handlingen setter sprintHeld til true, og Released til false, og Pressed på dash-handlingen kaller dash(). Fortsett å finne Humanoid hver frame, slik MovementClient gjør, fordi eksempelet i dokumentasjonen lagrer den første karakterens Humanoid, og etter en respawn er den borte.

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

Slik utvider du: animasjon, kamera og et sprint-pass

Sprintanimasjon

Lag en løpeanimasjon i Animation Editor, gi den prioriteten Movement (Roblox anbefaler den for gå- og løpeanimasjoner), publiser den og kopier asset-ID-en. I MovementClient lager du en Animation med den AnimationId, laster den med Animator:LoadAnimation ved hjelp av Animator inne i karakterens Humanoid, starter sporet der sprinten starter, og stopper det der den slutter. Last den på nytt for hver ny karakter.

Animasjoner som enheten din starter på karakteren din, kan ses av alle hvis du bruker den Animator som Roblox har lagt der: spor som er lastet på en Animator laget av et LocalScript, replikeres ikke. Humanoid:LoadAnimation, som mange gamle veiledninger bruker, er utdatert.

Bredere kamera under sprint

En litt bredere synsvinkel får sprinten til å føles raskere. På de samme to stedene tweener du workspace.CurrentCamera.FieldOfView fra standardverdien 70 til omtrent 80 når sprinten starter, og tilbake når den slutter, for eksempel med TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox begrenser verdien til mellom 1 og 120 og advarer om at svært lave eller svært høye verdier kan desorientere spillerne. Hvis et annet skript i spillet også endrer synsvinkelen, tween tilbake til verdien du fant, i stedet for til 70.

Rask sprint som gamepass

Gamepass-guiden virker allerede med dette skriptet: Speed-fordelen på serveren setter WalkSpeed til 24 for hver ny karakter, MovementClient legger sprintbonusen oppå, og 34 studs i sekundet holder seg innenfor det MovementCheck tillater.

For et pass som gjør selve sprinten raskere, legger du til passet FastSprint i PassConfig.ids fra den guiden. Server-skriptet der setter da attributtet OwnsPass_FastSprint på spilleren så snart kjøpet er bekreftet. I MovementClient bruker du en større bonus enn Config.SPRINT_BONUS når player:GetAttribute("OwnsPass_FastSprint") == true. I MovementCheck gir du slike spillere en større toleranse ved å lese det samme attributtet på serveren, der spilleren ikke kan endre det, og sjekker at den nye maksimale hastigheten holder seg under det sjekken flagger.

Én begrensning som er god å kjenne til: hvis et annet skript endrer WalkSpeed midt i en sprint, setter slutten av den sprinten hastigheten tilbake til den som var før. Neste respawn setter passets hastighet igjen, fordi gamepass-skriptet bruker den på hver ny karakter.

Vanlige feil og løsninger

Åpne Output-vinduet (menyen Window, deretter Output) før du trykker på Play. De fleste problemer med disse skriptene skriver en feil eller en advarsel der med skriptets navn og linjenummer.

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

MovementClient eller MovementCheck venter på en modul som ikke finnes med nøyaktig det navnet. Det må være et ModuleScript med navnet MovementConfig rett inne i ReplicatedStorage. Guiden til skriptfeil går gjennom denne advarselen i detalj.

Shift gjør ingenting

Sjekk at ShiftToSprint eller MovementClient er et LocalScript og ikke et Script, og at det ligger i StarterPlayerScripts. Med MovementClient må karakteren også gå og ha minst 20 stamina for å starte en sprint, så hold Shift nede mens du beveger deg. Hvis Shift Lock veksler i stedet for sprint, se spørsmålet om Shift Lock nedenfor.

Sprinten stopper etter noen sekunder

Det er staminaen som går tom: 100 stamina med 20 i sekundet holder i 5 sekunder. Øk MAX_STAMINA, eller senk DRAIN_PER_SECOND i MovementConfig.

Dashen gjør ingenting

Dashen krever 25 stamina, venter 1 sekund etter den forrige og gjør ingenting mens du sitter. Hvis det ikke er det, har kanskje rotparten til karakteren din ingen Attachment med navnet RootAttachment, noe som skjer med enkelte egne karakterer: legg den til i HumanoidRootPart i din StarterCharacter.

Dobbelthoppet virker ikke

DoubleJump må være et LocalScript i StarterCharacterScripts, ikke i StarterPlayerScripts, fordi det leser script.Parent som karakteren. Trykk på hopp en gang til etter at du har forlatt bakken: en knapp som holdes inne, teller ikke som et nytt trykk, og å gå utfor en kant gir ikke noe hopp i luften.

Det er ingen Sprint- eller Dash-knapp på mobilen

ContextActionService legger bare til knappene sine på berøringsenheter, så på en PC uten berøringsskjerm ser du dem aldri. Test med en telefon i Device Simulator i Studio (det er en beta: slå på New Device Simulator under File, Beta Features, og start Studio på nytt). BindAction kan lage høyst 7 berøringsknapper, så tell hvor mange andre skript i spillet lager.

MovementCheck klager på ærlige spillere

De vanlige årsakene: en teleport fra et annet server-skript, et transportbånd eller et kjøretøy, eller lag. Sett attributtet MovementCheckSkip etter teleportene dine (se Respawns og teleporter), og øk SPEED_ALLOWANCE hvis sjekken fortsatt utløses i vanlig spill.

Hastighetsøkningen forsvinner etter sprint

Et annet skript endret WalkSpeed under sprinten, og da sprinten sluttet, satte den hastigheten tilbake til den den så ved starten. Gi økninger når karakteren spawner, slik gamepass-guiden gjør, så en respawn setter riktig hastighet igjen.

Lag det med RoCode

Hvis du ikke har lyst til å sette opp alt dette for hånd, kan RoCode bygge det i placen du har åpen. RoCode er en uavhengig AI-agent for Roblox Studio, ikke fra Roblox: du beskriver endringen i webchatten, og Studio-pluginen lager skript i Explorer for deg, så du ikke trenger å lime inn kode.

Du skriver

Legg til sprint med Shift og en stamina-bar: ganghastighet pluss 10 mens Shift holdes nede, 100 stamina, forbruk 20 i sekundet, påfylling 15 i sekundet etter ett sekunds hvile, en Sprint-knapp på mobiler, dash på Q og dobbelthopp.

RoCode gjør
  • Kan først gå gjennom placen din med Search Scripts og Read Script for å finne andre skript som endrer WalkSpeed (for eksempel en gamepass-fordel), så sprinten legges oppå dem
  • Skriver ModuleScript, LocalScripts og sjekken på serveren med Create Script
  • Den er instruert til å sjekke kompileringen av hvert skript den skriver, med Check Script, som kompilerer det i Studio uten å kjøre det
  • Setter et angrepunkt før og etter hver pakke med endringer, så Ctrl+Z ruller tilbake én pakke om gangen

RoCode kan ikke lage en løpeanimasjon: lag den i Animation Editor og lim inn ID-en. Med plugin 3.9.11 eller nyere kan RoCode kjøre en playtest av spillet ditt i Studio og styre en testfigur for å sjekke at alt virker, og med plugin 3.9.15 eller nyere kan testfiguren trykke på taster, for eksempel holde Shift og sjekke at WalkSpeed økte. Den bestemmer selv når det kjøres en playtest, opptil 2 per build pluss 1 for å sjekke rettelsen sin, og sjekker bare det den selv har bestemt å teste, så prøv sprint, dash og dobbelthopp selv, og sjekk knappene på mobilen i Device Simulator i Studio. Bevegelse er ett system blant mange i et spill; å lage et helt spill med RoCode skjer ett system per prompt, som her. Slik kobler RoCode seg til Studio.

Ofte stilte spørsmål

Hvorfor virker ikke sprint-skriptet på mobilen?

En mobil har ingen Shift-tast. Bind sprint med ContextActionService:BindAction, og send true som tredje argument: det legger til en knapp på skjermen på berøringsenheter, slik både ShiftToSprint og MovementClient gjør.

Skal sprint lages på serveren?

Nei. Hver enhet flytter sin egen karakter, så en WalkSpeed satt av serveren stopper ikke en jukser som kan sette sin egen, og den nye hastigheten kommer først etter turen frem og tilbake, så sprinten starter med forsinkelse. Lag sprint på klienten, og sjekk på serveren hvor langt karakterene faktisk flytter seg, som i steg 5. Robloxs beta server authority fungerer annerledes, og bevegelseskoden må skrives om for den.

Hvorfor fortsetter karakteren å sprinte når jeg har sluppet Shift?

Skriptet gikk glipp av slippet, som regel fordi det bare lytter etter trykket. ContextActionService sender End når tasten slippes, og Cancel når en annen binding tar den over; MovementClient stopper ved begge, og også når staminaen går tom eller karakteren slutter å bevege seg.

Hvordan legger jeg til en sprintanimasjon?

Last en løpeanimasjon via Animator i karakterens Humanoid i det samme LocalScriptet, start den når sprinten starter, og stopp den når den slutter. Gi den prioriteten Movement. Animasjoner som startes på din egen karakter, kan ses av alle.

Hvorfor utløses dobbelthoppet av seg selv på mobilen?

En hoppknapp som holdes inne på mobilen, fortsetter å be om hopp. Regn et hopp som nytt bare hvis forespørslene har stoppet et øyeblikk, slik skriptet DoubleJump gjør.

Hva er standard ganghastighet i Roblox?

16 studs i sekundet. Den kommer fra StarterPlayer.CharacterWalkSpeed, som setter Humanoid.WalkSpeed for hver ny karakter. Sprinten fra denne guiden legger til 10, så sprint går med 26.

Hvor rask bør en sprint være i Roblox?

De fleste spill legger til mellom en halv og en hel ganghastighet: 16 blir noe mellom 24 og 32. En kort, langsom sprint passer til horror, og en lang, rask til store kart. Presets etter spilltype gir ganghastighet, sprintbonus og stamina-tall for hver.

Hvordan lager jeg sprint med stamina?

Lagre et stamina-tall på spillerens enhet, bruk av det hver frame under sprint, og fyll det opp etter en kort hvile, begge deler med hensyn til frametiden, og stopp sprinten når det når 0. MovementClient fra steg 3 gjør det med en bar på skjermen; tallene ligger i MovementConfig.

Hvordan sprinter man med kontroller i Roblox?

Bind gamepadens ButtonL3 (trykk på venstre stikke) med ContextActionService sammen med Left Shift, slik begge skriptene her gjør. ShiftToSprint gjør L3 til en bryter, fordi det er slitsomt å holde stikken inne og samtidig styre med den.

Kommer sprint med Shift i konflikt med Shift Lock?

Det kan den. Spillere som har slått på Shift Lock i Roblox-innstillingene, veksler den med Shift-tasten, så én tast gjør to ting. I Robloxs dokumentasjon står det at Shift Lock-API-ene fases ut. Hvis konflikten plager spillerne dine, slå av StarterPlayer.EnableMouseLockOption, eller bind sprint i MovementClient til en annen tast, for eksempel Left Ctrl.

Kilder og videre lesing

Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.

Prøv RoCode i ditt eget spill.

Gratis credits hver dag, uten kort. Installer pluginen, beskriv en funksjon og se hva som dukker opp i Studio.