Guide · Spelsystem

Så gör du sprint med Shift i Roblox Studio för PC, mobil och konsol

Sprint med Shift i Roblox handlar om ett enda tal: WalkSpeed på Humanoid, som ökar medan Shift hålls nere. Steg 1 gör exakt det i en kort LocalScript som också fungerar med Sprint-knappen på mobilen och med handkontroll. Resten av guiden lägger till det som ett större spel behöver: en staminamätare, en dash med modern fysik, ett dubbelhopp som inte utlöses av en nedhållen knapp, och en förståelse för vad servern kan kontrollera och vad den inte kan.

Uppdaterad 20 november 202625 min läsningSkriven av

I korthet

Lägg en LocalScript i StarterPlayerScripts som binder åtgärden Sprint med ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Medan Shift hålls nere, lägg till 10 på Humanoid.WalkSpeed (16 blir 26), och återställ det tidigare värdet när tangenten släpps. Argumentet true lägger till en Sprint-knapp på pekskärmar, och i skriptet i den här guiden slår den knappen och L3 på handkontrollen på och av sprinten i stället för att fungera med nedhållning.

  • Lägg till på den nuvarande WalkSpeed i stället för att sätta 26, så att en hastighetsökning från ett gamepass finns kvar.
  • Sprinten körs på spelarens enhet. Servern kan inte tvinga fram WalkSpeed; den kan bara mäta hur långt karaktärer rör sig och flagga hastigheter som sprinten inte förklarar.
  • En staminamätare, en dash och ett dubbelhopp med samma idé läggs till i steg 2 till 4. Hur snabbt och hur länge du ska sprinta får du hjälp med av förinställningarna per speltyp, med siffror för skräck, strid och öppen värld.
På den här sidan
  1. Så fungerar det
  2. 1. Sprint med Shift
  3. 2. Inställningsmodul
  4. 3. Sprint och dash
  5. 4. Dubbelhopp
  6. 5. Kontroll på servern
  7. 6. Testa
  8. Förinställningar
  9. Gamla skript
  10. Input Action System
  11. Bygg vidare
  12. Common errors
  13. Med RoCode
  14. Vanliga frågor
  15. Källor och vidare läsning

Så fungerar sprint i Roblox

IllustrationShift ger sprint med WalkSpeed 26 medan mätaren minskar, Q gör en dash för en fjärdedel av mätaren, och ett andra hopptryck i luften hoppar en gång till.

Varje spelares enhet flyttar spelarens egen karaktär. Tangentbordet, handkontrollen eller pekskärmen bestämmer vart karaktären går, och Roblox skickar resultatet till servern och alla andra. Därför är sprint en LocalScript som höjer Humanoid.WalkSpeed medan tangenten hålls nere, och det är allt steg 1 gör. Resten av guiden är det som ett större spel behöver runt omkring: en staminamätare, en dash, ett dubbelhopp och en serverkontroll mot fusk.

Vad rörelsesystemet består av
DelVar den liggerVad den gör
LocalScript ShiftToSprintStarterPlayerScriptsSteg 1 på egen hand: sprint på tangentbord, mobil och handkontroll, utan stamina. När du lägger till stamina och dash ersätts den av MovementClient.
ModuleScript MovementConfigReplicatedStorageSiffrorna: sprintbonus, stamina och dash. Både LocalScript och serverkontrollen läser dem.
LocalScript MovementClientStarterPlayerScriptsBinder Sprint och Dash till en tangent, en knapp på handkontrollen och en pekknapp, kör staminaloopen, ritar mätaren och gör dashen.
LocalScript DoubleJumpStarterCharacterScriptsGer ett extra hopp i luften. En ny kopia startar i varje ny karaktär.
Script MovementCheckServerScriptServiceMäter hur långt varje karaktär faktiskt rör sig och skriver en varning i Output när någon länge rör sig snabbare än sprint och dash tillåter.
Explorer när rörelsesystemet är klart
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Om skillnaden mellan Script och LocalScript är ny för dig förklarar Script, LocalScript och ModuleScript var varje typ körs och varför.

Steg 1: sprint med Shift i en enda LocalScript

Om du bara behöver snabbare löpning medan Shift hålls nere räcker det här skriptet. Det ger också mobiler en Sprint-knapp på skärmen och låter dig sprinta med vänster spak på handkontrollen.

  1. I Explorer, fäll ut StarterPlayer, håll muspekaren över StarterPlayerScripts, klicka på knappen + och infoga en LocalScript med namnet ShiftToSprint.
  2. Ersätt innehållet med koden nedan och klicka på Play.
LocalScript i StarterPlayerScripts med namnet ShiftToSprint
-- LocalScript i StarterPlayer > StarterPlayerScripts med namnet ShiftToSprint.
-- Håll Left Shift för att sprinta. På handkontrollen, tryck på vänster spak (L3) för att
-- slå på eller av sprinten. På mobilen, tryck på knappen Sprint för att slå på eller av den.

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

-- Inställningar
local SPRINT_BONUS = 10 -- läggs till på WalkSpeed under sprint (16 blir 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: knappen måste hållas nere

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- WalkSpeed att återgå till

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
		-- Spara nuvarande hastighet och lägg till på den, så att en ökning från ett annat skript finns kvar
		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
		-- Hålla in: sprint medan tangenten eller knappen är nedtryckt
		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
		-- Växla: varje tryck slår på eller av sprinten
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Ett anrop binder tangenten, knappen på handkontrollen och, på pekskärmar, en knapp på skärmen
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- En ny karaktär börjar med att gå: dess Humanoid har redan vanlig WalkSpeed
player.CharacterAdded:Connect(function()
	sprinting = false
end)

Ändra SPRINT_BONUS för att göra sprinten snabbare eller långsammare. Sätt TOGGLE_ON_TOUCH_AND_GAMEPAD till false för att mobilknappen och L3 ska fungera som Shift: sprint bara medan den hålls nere.

BindAction binder en åtgärd till Left Shift och till knappen L3 på handkontrollen, och dess tredje argument, true, lägger till en knapp på pekskärmar; SetTitle skriver "Sprint" på den. Hanteraren får också själva inmatningen, så den skiljer ett tryck på tangentbordet från handkontrollen eller pekknappen. När sprinten börjar sparar skriptet den nuvarande WalkSpeed och lägger till SPRINT_BONUS; när den slutar återställer det det sparade värdet. En hastighet som ett annat skript har satt, till exempel Speed-förmånen från guiden om gamepasses, finns kvar. En ny karaktär börjar med vanlig WalkSpeed, så hanteraren för CharacterAdded återställer bara flaggan.

Hålla in eller växla?

Hur ShiftToSprint fungerar på varje enhet när TOGGLE_ON_TOUCH_AND_GAMEPAD är true
Enhet och inmatningFungerar somVarför
Tangentbord: Left ShiftHålla inDet är lätt att hålla tangenten medan du rör dig, och när du släpper stannar sprinten direkt.
Handkontroll: tryck på vänster spak (L3)VäxlaAtt hålla spaken nedtryckt och samtidigt styra med den är tröttsamt.
Mobil eller surfplatta: Sprint-knappen på skärmenVäxlaTummen som håller knappen kan inte samtidigt trycka på Jump.

För att testa, klicka på Play och håll Shift medan du går: hastigheten ökar från 16 till 26 studs per sekund, och när du släpper saktar du ner. För mobil, välj en telefon i Device Simulator i Studio, klicka på Play och tryck på Sprint en gång för att börja och en gång till för att sluta. För handkontroll, öppna Controller Emulator under ett speltest och tryck på L3. Hela listan med kontroller per enhet finns i steg 6.

Steg 2 och 3 ersätter det här skriptet med ett annat, med en staminamätare och en dash. Steg 4 och 5 lägger till dubbelhopp och en serverkontroll och fungerar med vilket som helst av de två skripten.

Steg 2: siffrorna för stamina och dash i en modul

För en sprint som tar slut byter steg 2 och 3 ut ShiftToSprint mot en större LocalScript med en staminamätare och en dash. Ta först bort ShiftToSprint: båda skripten binder åtgärden Sprint.

Alla siffror ligger i en ModuleScript, så känslan i rörelsen ställs in på ett ställe. MovementClient läser dem på varje spelares enhet, och MovementCheck läser samma modul på servern för att veta hur snabb sprinten och dashen ska vara.

  1. I Explorer, håll muspekaren över ReplicatedStorage, klicka på knappen + och infoga en ModuleScript.
  2. Byt namn på den till MovementConfig och ersätt innehållet med koden nedan.
ModuleScript i ReplicatedStorage med namnet MovementConfig
-- En uppsättning siffror för rörelsens LocalScript och serverns hastighetskontroll.

local MovementConfig = {
	SPRINT_BONUS = 10, -- läggs till på nuvarande WalkSpeed: 16 (Robloxs standardvärde) blir 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 sekunders sprint på en full mätare
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- sekunder efter att sprinten slutat innan staminan börjar återhämtas
	MIN_TO_START = 20, -- stamina som krävs för att börja sprinta, så att en tom mätare inte flimrar

	DASH_SPEED = 60, -- studs per sekund under en dash
	DASH_SECONDS = 0.2, -- så en dash går ungefär 12 studs
	DASH_COST = 25, -- stamina
	DASH_COOLDOWN = 1,
}

return MovementConfig
Vad varje inställning gör
InställningVärdeEffekt
SPRINT_BONUS10Läggs till på WalkSpeed under sprint. Standardvärdet för WalkSpeed i Roblox är 16, så sprinten går i 26 studs per sekund.
MAX_STAMINA100En full mätare.
DRAIN_PER_SECOND20En full mätare räcker till 5 sekunders sprint.
REGEN_PER_SECOND15En tom mätare fylls på ungefär 6.7 sekunder.
REGEN_DELAY1Sekunder av vila innan återhämtningen börjar.
MIN_TO_START20Stamina som behövs för att börja sprinta.
DASH_SPEED60Studs per sekund under en dash.
DASH_SECONDS0.2Hur länge en dash varar: ungefär 12 studs vid 60 studs per sekund.
DASH_COST25Stamina för varje dash.
DASH_COOLDOWN1Sekunder mellan dashar.

Varje sida kör sin egen kopia av modulen (en modul körs en gång på varje sida), så en spelare som ändrar siffrorna på sin enhet ändrar bara sin egen kopia. Men här skyddar det ingenting: spelarens enhet flyttar ändå spelarens karaktär och kan därför ge sig själv oändlig stamina, oavsett vad som står i modulen. Serverkontrollen i steg 5 är byggd med det i åtanke.

Steg 3: sprint med stamina och dash

Den här LocalScript gör det som spelarna känner. Den binder Sprint och Dash, ritar staminamätaren, kör staminaloopen varje bildruta och gör dashen.

  1. I Explorer, fäll ut StarterPlayer, håll muspekaren över StarterPlayerScripts och infoga en LocalScript med namnet MovementClient.
  2. Ersätt innehållet med koden nedan.
LocalScript i StarterPlayerScripts med namnet MovementClient
-- Håll Shift (eller L3, eller knappen Sprint på mobilen) för att sprinta så länge det finns stamina.
-- Tryck på Q (eller B, eller knappen Dash) för att göra en dash i rörelseriktningen.

local ContextActionService = game:GetService("ContextActionService")
local Debris = game:GetService("Debris")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

type Config = {
	SPRINT_BONUS: number,
	MAX_STAMINA: number,
	DRAIN_PER_SECOND: number,
	REGEN_PER_SECOND: number,
	REGEN_DELAY: number,
	MIN_TO_START: number,
	DASH_SPEED: number,
	DASH_SECONDS: number,
	DASH_COST: number,
	DASH_COOLDOWN: number,
}
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config

local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- WalkSpeed att återgå till när sprinten slutar
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Staminamätare: en ram med en fyllning vars bredd motsvarar återstående 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: här bara en flagga; Heartbeat-loopen nedan avgör varje bildruta om det ska sprintas
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Bara tryck och släpp ändrar den: ett finger som glider över pekknappen skickar 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 sittande: en sittande karaktär är svetsad fast i sätet och skulle knuffa hela fordonet
	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 -- pausa återhämtningen, precis som sprinten gör

	-- Dash dit spelaren rör sig, eller dit den tittar om den står still
	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 läget Plane håller den horisontella hastigheten och stör inte gravitationen
	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

-- Varje anrop binder en tangent, en knapp på handkontrollen och, på pekenheter, en knapp 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")

-- Varje bildruta: förbruka stamina under sprint och rörelse, återhämta efter en kort vila
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

	-- Ändra WalkSpeed bara när sprinten börjar och slutar, så att en hastighet som satts
	-- av ett annat skript (till exempel ett hastighetspass) finns kvar och sprinten läggs ovanpå 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 karaktär börjar med full stamina och ingenting nedtryckt
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- en ny Humanoid börjar med vanlig WalkSpeed
end)

Staminamätaren skapas i koden med ResetOnSpawn satt till false, så den finns kvar på skärmen efter en återuppståndelse, och hanteraren för CharacterAdded längst ner fyller den igen för varje ny karaktär. Raderna type Config beskriver vad modulen returnerar, så att strikt typkontroll fångar ett stavfel i namnet på en inställning; under spelets gång ändrar de ingenting.

Tangentbord, handkontroll och mobilknapp i ett anrop

ContextActionService:BindAction tar emot åtgärdens namn, en hanterarfunktion, om en pekknapp ska skapas, och sedan inmatningarna. Om du skickar true som tredje argument lägger ContextActionService till en knapp på skärmen på pekenheter, inuti en ScreenGui med namnet ContextActionGui i spelarens PlayerGui. SetTitle skriver "Sprint" och "Dash" på knapparna. BindAction kan skapa högst 7 pekknappar, så håll koll på antalet om andra skript i spelet också använder dem.

Hanteraren får inmatningens tillstånd: Begin vid tryck och End vid släpp. onSprint kommer bara ihåg om Sprint hålls nere. Den räknar också Cancel som ett släpp, som ContextActionService skickar när en annan bindning tar över inmatningen, och ignorerar Change, som ett finger som rör sig över pekknappen kan skicka. Båda hanterarna returnerar Pass, så att nästa bindning på samma tangent också får inmatningen.

Robloxs referens för ContextActionService rekommenderar den framför UserInputService.InputBegan i de flesta fall. Dess exempel: en biltuta på H som inte ska tuta medan spelaren skriver i chatten. En bindning utlöses bara medan den är den senaste för den inmatningen, så när chatten tar över tangentbordet behöver du inte kontrollera något. Inmatningar på handkontrollen: ButtonL3 (tryck på vänster spak, som hålls under rörelse) och ButtonB. I Robloxs eget sprintexempel används ButtonY, så byt KeyCode i BindAction om det passar ditt spel bättre.

Staminaloopen

RunService.Heartbeat utlöses varje bildruta efter fysiksteget och skickar deltaTime, antalet sekunder sedan förra bildrutan. Om du multiplicerar förbruknings- och återhämtningstakten med det räcker en full mätare i 5 sekunder, oavsett om spelet går i 30 eller 240 bildrutor per sekund.

Varje bildruta avgör loopen om karaktären ska sprinta: Sprint hålls nere, karaktären går (Humanoid.MoveDirection är nollvektorn när den står still) och det finns stamina kvar. För att börja sprinta krävs minst MIN_TO_START (20); för att fortsätta räcker allt över 0. Utan den marginalen skulle en tom mätare, som fylls en aning varje bildruta, slå på och av sprinten varje bildruta. Återhämtningen börjar REGEN_DELAY (1 sekund) efter den senaste sprinten eller dashen, så när spelaren tömt mätaren väntar den ungefär 2.3 sekunder innan den kan sprinta igen.

WalkSpeed ändras bara den bildruta då sprinten börjar eller slutar. Vid start sparar skriptet den nuvarande WalkSpeed och lägger till SPRINT_BONUS; vid slutet återställer det det sparade värdet. Därför finns en hastighet som ett annat skript har satt kvar: Speed-förmånen från guiden om gamepasses sätter WalkSpeed 24, och med det här skriptet sprintar dess ägare i 34. Ett skript som skriver WalkSpeed = 16 varje bildruta eller vid varje släpp skulle i tysthet ta bort förmånen.

Dashen

Dashen knuffar karaktären dit den rör sig, eller dit den tittar om den står still, och riktningen plattas till så att den aldrig pekar uppåt eller nedåt. Den kostar 25 stamina, pausar återhämtningen precis som sprinten och har en cooldown på 1 sekund. Den kontrollerar inte marken, så den fungerar också i luften, vilket passar bra ihop med dubbelhoppet. Medan karaktären sitter gör dashen ingenting: en sittande karaktär är svetsad fast i sätet, och i ett fordon skulle knuffen kunna flytta hela fordonet.

Knuffen är en LinearVelocity-constraint på rotpartens RootAttachment. I läget Plane med axlarna X och Z håller den en horisontell hastighet på 60 studs per sekund och rör inte det vertikala, så gravitationen fungerar, och en dash från en kant faller som vanligt. MaxForce är math.huge, så knuffen begränsas inte av något. Debris:AddItem förstör constrainten efter DASH_SECONDS utan att få skriptet att vänta, så dashen varar 0.2 sekunder, ungefär 12 studs i den hastigheten.

Äldre guider använder BodyVelocity, som Roblox har markerat som föråldrad med en anvisning om att använda LinearVelocity i stället. Dess trick med noll MaxForce på en axel ersätts av lägena Line, Plane och Vector i LinearVelocity. Eftersom spelarens enhet själv simulerar sin karaktär flyttar en constraint som skapats av en LocalScript den, och andra spelare ser dashen som vilken annan rörelse som helst.

Robloxs egen UI-guide fäster constrainten på humanoid.RootPart.RootAttachment på exakt samma sätt. Om ditt spel har en egen karaktär vars rotpart saknar en Attachment med namnet RootAttachment gör dashen ingenting: lägg till en i HumanoidRootPart i din StarterCharacter.

Steg 4: dubbelhopp

Dubbelhoppet bor i en egen LocalScript i StarterCharacterScripts. Roblox lägger en kopia av skripten från den behållaren i varje karaktär när den spawnar, och kopiorna överlever inte en återuppståndelse, så varje liv börjar med ett nytt skript, och ingenting förs över från det förra.

  1. I Explorer, fäll ut StarterPlayer, håll muspekaren över StarterCharacterScripts och infoga en LocalScript med namnet DoubleJump.
  2. Ersätt innehållet med koden nedan.
LocalScript i StarterCharacterScripts med namnet DoubleJump
-- Ger ett extra hopp i luften. Startar om för varje ny karaktär,
-- så ingenting förs över efter en återuppståndelse.

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 flera gånger per tryck
local NEW_PRESS_GAP = 0.1 -- en nedhållen hoppknapp fortsätter skicka JumpRequest; en paus av den här längden betyder att den släppts

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
		-- Ett hopp från marken (inte ett av våra hopp i luften) ger tillbaka hoppen i luften
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest utlöses när spelaren ber om ett hopp, till exempel med Space eller hoppknappen på mobilen
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Bara ett nytt tryck hoppar igen, så att en nedhållen knapp inte förbrukar 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ätt EXTRA_JUMPS till 2 för ett trippelhopp.

Skriptet följer karaktärens tillstånd via Humanoid.StateChanged. En övergång till Jumping som inte kom från Freefall är ett hopp från marken, så det ger ett hopp i luften, och Landed tar bort det igen. Om karaktären kliver av en kant hamnar den i Freefall utan att hoppa och får därför inget hopp i luften. Om du vill ha det även där, sätt jumpsLeft också vid övergången till Freefall från alla tillstånd utom Jumping.

UserInputService.JumpRequest utlöses när spelaren ber om ett hopp, till exempel med Space eller hoppknappen på mobilen. Robloxs referens varnar för att den utlöses flera gånger per hoppförfrågan och rekommenderar en debounce, så skriptet ignorerar förfrågningar i 0.25 sekunder efter det senaste hoppet. En nedhållen hoppknapp kan också fortsätta begära hopp och skulle förbruka hoppet i luften i samma ögonblick som karaktären lämnar marken, så en förfrågan räknas som ett nytt tryck först efter 0.1 sekunder utan förfrågningar.

Själva hoppet i luften är Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Robloxs referens säger att det ska anropas från en LocalScript på den enhet som har nätverksägandet över karaktären, och som standard är det spelarens egen enhet, inte servern. Kodexemplet till ChangeState i referensen är just ett dubbelhopp.

Steg 5: fånga speedhacks på servern

Guider om sprint stannar ofta vid klienten. Ett server-Script kan inte lita på spelarens WalkSpeed, eftersom exploiters ändrar den på sin enhet, men det ser var deras karaktär hamnar. MovementCheck mäter det två gånger per sekund och skriver en varning i Output när någon länge rör sig snabbare än sprint och dash tillåter. Siffrorna för sprint och dash läser den från MovementConfig, så lägg till den modulen från steg 2 även om du behöll ShiftToSprint.

  1. Håll muspekaren över ServerScriptService och infoga ett Script med namnet MovementCheck.
  2. Ersätt innehållet med koden nedan.
Script i ServerScriptService med namnet MovementCheck
-- Spelarnas enheter flyttar sina karaktärer, så en exploiter kan sätta vilken WalkSpeed som helst.
-- Den här kontrollen mäter hur långt varje karaktär faktiskt rör sig och skriver i Output
-- när någon länge rör sig snabbare än sprint och dash tillåter. Den varnar bara:
-- lagg, teleporteringar och löpande band kan se ut som för hög hastighet, så ställ in den innan du straffar någon.

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 plus marginal för lagg. Höj den om du säljer hastighetsökningar.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- marginal för en eller två dashar
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- hur snabbt tidigare dashar förlåts

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- rotparten som lastPosition mättes på
local excess: { [Player]: number } = {} -- studs över toleransen, förlåts 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 återuppståndelse är en ny rotpart, och en serverteleportering (rundstart, checkpoint)
			-- sätter attributet nedan: börja mäta på nytt i stället för att flagga 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
				-- Bara horisontell rörelse: att falla snabbt är inte fusk
				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

Varningen visas i Output i Studio. I det publicerade spelet hamnar den i serverloggen i Developer Console, som du kan läsa som spelets ägare: se utdata i det publicerade spelet.

Vad den mäter

Varje halv sekund läser skriptet positionen för varje karaktärs rotpart och mäter hur långt den har flyttat sig horisontellt sedan förra kontrollen. Höjden ignoreras, så fall och hopp räknas aldrig; Robloxs råd om rörelsekontroll föreslår samma projektion på XZ-planet för spel där man går på marken. Toleransen är standardgånghastigheten plus sprintbonusen och ytterligare en fjärdedel för lagg: 32.5 studs per sekund. Avstånd utöver det hamnar i en "läckande hink", en ackumulator som Robloxs dokumentation säger passar många utvecklare bra för korta ryck. Hinken tappar 3 studs varje kontroll, och skriptet varnar när den innehåller mer än 24 studs, vilket är marginal för ungefär två dashar.

Vad kontrollen fångar, räknat utifrån dess siffror
FuskarenVad MovementCheck gör
Sätter WalkSpeed 100Varnar efter ungefär en sekunds löpning
Sätter WalkSpeed 50Varnar efter ungefär 2.5 sekunders löpning
Gör dashar i följd utan cooldown (60 studs per sekund)Varnar efter ungefär 1.5 sekunder
Teleporterar sig mer än 43 studs åt gångenVarnar vid nästa kontroll
Springer i upp till 38 studs per sekund, ungefär en och en halv gång snabbare än sprintenIngenting: under 38.5 studs per sekund töms hinken lika snabbt som den fylls
Ändrar sin MovementConfig för oändlig staminaIngenting: sprint i 26 studs per sekund är tillåten hur länge som helst
Flyger, hoppar utan begränsning eller går genom väggarIngenting: kontrollen ignorerar höjd och tittar inte på kollisioner

Kontrollen fångar alltså grova fusk där spelaren är märkbart snabbare än alla andra och släpper igenom försiktiga. Det är den ärliga gränsen för en avståndskontroll och anledningen till att Roblox bygger något kraftfullare (se server authority nedan).

Varför den bara varnar

Robloxs dokumentation påpekar att enkla hastighetskontroller kan flagga ärliga spelare med instabil anslutning och går sönder i spel med fordon eller annan komplicerad rörelse. Laggspikar, löpande band, fordon, explosioner som kastar iväg karaktärer och dina egna teleporteringar kan se ut som för hög hastighet, så skriptet skriver bara ut en varning. Titta i Output medan du och dina testare spelar som vanligt, höj SPEED_ALLOWANCE om ärliga spelare fastnar i den, och lägg till ett straff, till exempel att flytta tillbaka spelaren, först när kontrollen är tyst i vanligt spel. Om explosioner kastar iväg karaktärer i ditt spel, hoppa också över spelare vars Humanoid inte har något liv kvar.

Återuppståndelser och teleporteringar

En återuppståndelse skapar en ny rotpart, och skriptet börjar mäta på nytt när det ser den, så att dö långt från spawnpunkten räknas aldrig som för hög hastighet. Teleporteringar som dina egna serverskript gör behöver ett undantag, som Robloxs dokumentation säger för alla spel med teleportering. Efter en teleportering, lägg till player:SetAttribute("MovementCheckSkip", true), så börjar nästa kontroll mäta från den nya positionen i stället för att flagga hoppet:

Plattorna och menyerna från guiden om teleportering och Finish-plattan från guiden om ditt första spel sätter redan attributet efter varje förflyttning.

Bara värdet från servern räknas. Ett attribut som spelaren sätter på sin enhet stannar på den enheten (se vad som replikeras och vad som inte gör det), så en fuskare kan inte stänga av kontrollen med det.

En lösning för framtiden: server authority

Robloxs säkerhetsdokumentation kallar modellen server authority, i beta när detta skrivs, det mest tillförlitliga sättet att stoppa rörelseexploits. Servern blir sanningskällan, och spelarnas enheter rapporterar bara sin inmatning, vilket enligt dokumentationen stoppar speedhacks eftersom enheten aldrig får förtroendet att rapportera sin egen position.

Övergången är en omskrivning, inte en inställning. I den modellen räknar servern ut rörelsen, så WalkSpeed eller LinearVelocity som bara en LocalScript sätter skrivs över när tillståndet från servern kommer. Robloxs dokumentation säger att huvudlogiken ska köras i funktioner för RunService:BindToSimulation() i en ModuleScript som både klienten och servern kör. Modellen kräver också några Workspace-inställningar, bland annat PlayerScriptsUseInputActionSystem, så din styrning flyttar också över till Input Action System. Behåll versionen från den här guiden tills du har flyttat sprint, stamina och dash till det upplägget. Till dess är en avståndskontroll som den här just det som Robloxs avsnitt om rörelsekontroll beskriver.

Steg 6: testa på varje enhet

  1. Klicka på Play och håll Shift medan du går. Hastigheten ökar från 16 till 26 studs per sekund, och den gröna mätaren längst ner på skärmen minskar. Efter ungefär 5 sekunder är den tom, och du går igen.
  2. Släpp Shift. Efter 1 sekund börjar mätaren fyllas. Tills den är fylld till en femtedel gör Shift ingenting.
  3. Tryck på Q medan du går: du rusar en bit framåt, och en fjärdedel av mätaren är borta. Tryck på Q igen direkt, så händer ingenting förrän en sekund har gått. Om dashen känns för kort eller för lång, ändra DASH_SPEED eller DASH_SECONDS i MovementConfig.
  4. Hoppa och tryck sedan på hopp igen i luften för ett andra hopp. Landa och försök igen: varje hopp från marken ger tillbaka hoppet i luften.
  5. Håll Space nere under hela hoppet. Det ska bli ett hopp, inte två, eftersom hoppet i luften kräver ett nytt tryck.
  6. Slå på Device Simulator i Studio (när detta skrivs är det en beta: File, Beta Features, New Device Simulator, och starta sedan om Studio) eller slå på den gamla Device Emulator i menyn Test. Välj en telefon och klicka på Play. Knapparna Sprint och Dash dyker upp. Håll Sprint medan du styr, håll sedan hoppknappen under hela hoppet och kontrollera att det bara blir ett hopp.
  7. Öppna Controller Emulator (Controller på fliken Emulation eller Virtual controller i panelen Device Simulator). Håll L3 under rörelse för att sprinta, tryck på B för en dash och på A två gånger för ett dubbelhopp.
  8. Återställ karaktären via spelets meny. Mätaren är full igen, det finns ingen varning från MovementCheck i Output, och om du fortfarande simulerar en telefon finns knapparna Sprint och Dash kvar.
  9. Spela nu som fuskare. Klicka på växlaren Client/Server tills Explorer visar klienten, markera din karaktärs Humanoid i Workspace och sätt WalkSpeed till 60 i fönstret Properties. Gå omkring i några sekunder: en varning som MovementCheck: YourName moved 60 studs/s dyker upp i Output. Sätt tillbaka 16, sprinta och dasha som vanligt i en minut och kontrollera att Output är tyst.
  10. Om Workspace.PlayerScriptsUseInputActionSystem är satt till Enabled i din place, testa dubbelhoppet igen: Robloxs dokumentation säger inte om JumpRequest beter sig likadant med den.

Om ingenting alls händer, öppna Output-fönstret via menyn Window i Studio och leta efter ett rött fel från MovementClient, eller titta i vanliga fel.

Hur snabbt och hur länge: förinställningar per speltyp

Rätt sprint beror på spelet. En jakt i ett skräckspel behöver en kort, långsam sprint som tar slut i värsta tänkbara ögonblick; en stor öppen karta behöver en lång, så att spelarna inte tröttnar på att korsa den. De här förinställningarna använder samma skript och ändrar bara gånghastigheten och MovementConfig. Det är våra startpunkter, uträknade från inställningarna, inte uppmätta på spelare.

Gånghastighet, sprint och stamina per speltyp. Sprinttiden är MAX_STAMINA / DRAIN_PER_SECOND; återhämtningen är MAX_STAMINA / REGEN_PER_SECOND plus 1 sekunds REGEN_DELAY
SpeltypCharacterWalkSpeedSPRINT_BONUS (sprinthastighet)DRAIN_PER_SECONDREGEN_PER_SECONDFull sprintFrån tom till fullSträcka på en mätare
Den här guiden1610 (26)20155 s7.7 s130 studs
Jakt i skräckspel128 (20)25104 s11 s80 studs
Battlegrounds och strid1612 (28)15206.7 s6 sungefär 187 studs
Öppen värld eller simulator1616 (32)102510 s5 s320 studs
Obby eller parkour168 (24)ingen stamina: använd ShiftToSprint
  • Gånghastigheten ställs in i StarterPlayer. Markera StarterPlayer och sätt CharacterWalkSpeed (standard 16). Varje ny karaktär börjar med den hastigheten, sprinten lägger till SPRINT_BONUS på den, och MovementCheck läser den också, så serverkontrollen följer ditt val.
  • MovementCheck anpassar sig. Den tillåter gånghastigheten plus sprintbonusen och ytterligare en fjärdedel för lagg: 25 studs per sekund för skräckförinställningen, 40 för öppen värld. Inget annat behöver ändras.
  • I en obby ändrar sprinten banan. Med snabbare sprint går det att hoppa över längre gap. Bygg hoppen och testa sedan vart och ett i sprinthastighet, annars gör sprinten etapperna för lätta. Guiden om checkpoints för obby passar bra ihop med ShiftToSprint.
  • I ett skräckspel är mördaren måttstocken. Gör förföljaren lite snabbare än gånghastigheten och lite långsammare än sprinten, så att flykten beror på när mätaren tar slut. Guiden om skräckspel går igenom resten av loopen.

Vad som är fel med gamla sprintskript

Gamla guider om sprint, dash och dubbelhopp fungerar ofta fortfarande, men många använder knep som Roblox sedan dess har ersatt, eller förstör andra system i ditt spel. Om du lagar ett kopierat skript, jämför det med den här listan.

Knep från gamla guider och vad den här guiden gör i stället
KnepVad problemet ärDen här guiden
BodyVelocity för dashenFöråldrad: Roblox säger att du ska använda LinearVelocity i ställetLinearVelocity i läget Plane
En loop på RunService.RenderSteppedFör nytt arbete har den ersatts av PreRender. Spellogik som stamina hör hemma på Heartbeat, som Roblox beskriver för återkommande uppgifter som att återhämta hälsaHeartbeat med deltaTime
En staminaloop på wait()wait() är föråldrad till förmån för task.wait() och stryps, så den kan vänta längre än begärt, och en fast förbrukning per wait drar stamina ojämntFörbrukning och återhämtning varje bildruta med hänsyn till deltaTime
UserInputService.InputBegan utan kontroll av chattenEtt tryck på Shift medan man skriver ett meddelande i chatten startar sprintenContextActionService, som dessutom lägger till en knapp på mobilen
WalkSpeed = 16 vid släpp eller varje bildrutaSkriver över alla andra hastigheter, till exempel en gamepass-förmånÄndrar WalkSpeed bara när sprinten börjar och slutar, och lägger till på det nuvarande värdet
Sprint via RemoteEvent så att servern sätter WalkSpeedExploiters sätter ändå sin WalkSpeed själva, och sprinten startar med en fördröjning för vägen fram och tillbakaSprint på klienten plus en avståndskontroll på servern
Dubbelhopp vid varje JumpRequestJumpRequest utlöses flera gånger per hoppförfrågan, och en nedhållen knapp kan fortsätta begära hoppEn paus på 0.25 sekunder och en kontroll av nytt tryck
UserInputService.TouchEnabled som kontroll av "det är en telefon"Den är true på bärbara datorer med pekskärmContextActionService lägger till knappar på skärmen på pekenheter utan någon egen enhetskontroll
Humanoid:LoadAnimation för sprintanimationenFöråldrad till förmån för Animator:LoadAnimationSprintanimationen nedan använder Animator

Robloxs nya sätt: Input Action System

Robloxs sida om Input Action System använder karaktärens sprint som första exempel. I stället för anrop till BindAction ställs styrningen in i Studio: en InputAction med namnet CharacterSprint inuti en input context i ReplicatedStorage, med en InputBinding för Left Shift, en för knappen Y på handkontrollen och en kopplad till en knapp på skärmen som du ritar i StarterGui. Sedan lyssnar ett klientskript på åtgärdens händelser Pressed och Released, fördubblar WalkSpeed vid tryck och återställer den vid släpp.

Det är värt att byta om du vill lägga upp styrningen i Studio i stället för i kod, ha en egen pekknapp i stället för ContextActionServices knapp, eller använda kontexter som byter hela uppsättningar styrning, till exempel för menyer eller fordon. Sidan rekommenderar också att sätta Workspace.PlayerScriptsUseInputActionSystem till Enabled, och server authority kräver det.

Staminaloopen och dashen från den här guiden fungerar likadant med bara Input Action System (utan server authority). Behåll MovementConfig, Heartbeat-loopen och dash(), ta bort de två anropen till BindAction och deras hanterare och koppla in åtgärderna i stället: sprintåtgärdens Pressed sätter sprintHeld till true och dess Released till false, och dashåtgärdens Pressed anropar dash(). Fortsätt att leta upp Humanoid varje bildruta som MovementClient gör, eftersom exemplet i dokumentationen sparar den första karaktärens Humanoid, och efter en återuppståndelse finns den inte längre.

Roblox testar också Character Controller Library, en beta som slås på under Beta Features och Avatar Settings i Studio. Dess sida om egna förmågor bygger som exempel en dash med ett aktivt fönster på 0.2 sekunder och en cooldown på 1 sekund, alltså samma timing som dashen i den här guiden.

Bygg vidare: animation, kamera och ett sprintpass

Sprintanimation

Gör en löpanimation i Animation Editor, ge den prioriteten Movement (Roblox rekommenderar den för gång- och löpanimationer), publicera den och kopiera asset-ID:t. I MovementClient, skapa en Animation med det AnimationId, ladda den med Animator:LoadAnimation via den Animator som finns inuti karaktärens Humanoid, starta spåret där sprinten börjar och stoppa det där den slutar. Ladda den igen för varje ny karaktär.

Animationer som din enhet spelar upp på din karaktär ser alla, om du använder den Animator som Roblox lade dit: spår som laddats på en Animator som skapats av en LocalScript replikeras inte. Humanoid:LoadAnimation, som många gamla guider använder, är föråldrad.

Bredare kamera under sprint

En något bredare synvinkel gör att sprinten känns snabbare. På samma två ställen, tweena workspace.CurrentCamera.FieldOfView från standardvärdet 70 till ungefär 80 när sprinten börjar och tillbaka när den slutar, till exempel med TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox begränsar värdet till mellan 1 och 120 och varnar för att mycket låga eller mycket höga värden kan desorientera spelare. Om något annat skript i spelet också ändrar synvinkeln, tweena tillbaka till det värde du hittade, inte till 70.

Snabbare sprint som gamepass

Guiden om gamepasses fungerar redan med det här skriptet: dess Speed-förmån på servern sätter WalkSpeed 24 för varje ny karaktär, MovementClient lägger till sprintbonusen ovanpå, och 34 studs per sekund håller sig inom det som MovementCheck tillåter.

För ett pass som gör själva sprinten snabbare, lägg till ett pass FastSprint i PassConfig.ids från den guiden. Dess serverskript sätter då attributet OwnsPass_FastSprint på spelaren så snart köpet är bekräftat. I MovementClient, använd en större bonus än Config.SPRINT_BONUS när player:GetAttribute("OwnsPass_FastSprint") == true. I MovementCheck, ge de spelarna en större tolerans genom att läsa samma attribut på servern, där spelaren inte kan ändra det, och kontrollera att den nya maxhastigheten håller sig under det som kontrollen flaggar.

En begränsning som är bra att känna till: om ett annat skript ändrar WalkSpeed mitt i en sprint återställer slutet av sprinten den hastighet som gällde före den. Nästa återuppståndelse sätter passets hastighet igen, eftersom gamepass-skriptet tillämpar den på varje ny karaktär.

Vanliga fel och lösningar

Öppna Output-fönstret (menyn Window, sedan Output) innan du klickar på Play. De flesta problem med de här skripten skriver ut ett fel eller en varning där, med skriptets namn och radnumret.

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

MovementClient eller MovementCheck väntar på en modul som inte finns med exakt det namnet. Det ska vara en ModuleScript med namnet MovementConfig direkt inuti ReplicatedStorage. Guiden om skriptfel går igenom den varningen i detalj.

Shift gör ingenting

Kontrollera att ShiftToSprint eller MovementClient är en LocalScript, inte ett Script, och att den ligger i StarterPlayerScripts. Med MovementClient måste karaktären dessutom gå och ha minst 20 stamina för att börja sprinta, så håll Shift medan du rör dig. Om Shift Lock växlar i stället för sprinten, se frågan om Shift Lock nedan.

Sprinten slutar efter några sekunder

Det är staminan som tar slut: 100 stamina med 20 per sekund räcker i 5 sekunder. Höj MAX_STAMINA eller sänk DRAIN_PER_SECOND i MovementConfig.

Dashen gör ingenting

Dashen kräver 25 stamina, väntar 1 sekund efter den förra och gör ingenting medan du sitter. Om det inte är det kan din karaktärs rotpart sakna en Attachment med namnet RootAttachment, vilket händer med vissa egna karaktärer: lägg till en i HumanoidRootPart i din StarterCharacter.

Dubbelhoppet fungerar inte

DoubleJump måste vara en LocalScript i StarterCharacterScripts, inte i StarterPlayerScripts, eftersom den läser script.Parent som karaktären. Tryck på hopp en andra gång efter att du lämnat marken: en nedhållen knapp räknas inte som ett nytt tryck, och att kliva av en kant ger inget hopp i luften.

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

ContextActionService lägger bara till sina knappar på pekenheter, så på en PC utan pekskärm syns de aldrig. Testa med en telefon i Device Simulator i Studio (det är en beta: slå på New Device Simulator under File, Beta Features och starta om Studio). BindAction kan skapa högst 7 pekknappar, så räkna hur många som andra skript i spelet gör.

MovementCheck klagar på ärliga spelare

Vanliga orsaker: en teleportering från ett annat serverskript, ett löpande band eller ett fordon, eller lagg. Sätt attributet MovementCheckSkip efter dina teleporteringar (se Återuppståndelser och teleporteringar) och höj SPEED_ALLOWANCE om kontrollen fortfarande utlöses i vanligt spel.

Hastighetsökningen försvinner efter en sprint

Ett annat skript ändrade WalkSpeed under sprinten, och när sprinten slutade återställde den hastigheten den såg vid starten. Ge hastighetsökningar när karaktären spawnar, som guiden om gamepasses gör, så att en återuppståndelse sätter rätt hastighet igen.

Gör det med RoCode

Om du inte vill ställa in allt det här för hand kan RoCode bygga det i den place du har öppen. RoCode är en oberoende AI-agent för Roblox Studio, inte från Roblox: du beskriver ändringen i webbchatten, och dess Studio-plugin skapar skripten i din Explorer, så du behöver inte klistra in någon kod.

Du skriver

Lägg till sprint med Shift och en staminamätare: gånghastighet plus 10 medan Shift hålls nere, 100 stamina, förbrukning 20 per sekund, återhämtning 15 per sekund efter en sekunds vila, en Sprint-knapp på mobiler, dash på Q och dubbelhopp.

RoCode gör
  • Kan först gå igenom din place med Search Scripts och Read Script för att hitta andra skript som ändrar WalkSpeed (till exempel en gamepass-förmån), så att sprinten läggs ovanpå dem
  • Skriver ModuleScript, LocalScripts och serverkontrollen med Create Script
  • Den är instruerad att kontrollera att varje skript den skrivit kompilerar med Check Script, som kompilerar det i Studio utan att köra det
  • Sätter en ångrapunkt före och efter varje omgång ändringar, så Ctrl+Z backar en omgång i taget

RoCode kan inte göra en sprintanimation: skapa den i Animation Editor och klistra in dess ID. Med plugin 3.9.11 eller nyare kan RoCode köra ett speltest av ditt spel i Studio och styra en testkaraktär för att kontrollera att allt fungerar, och med plugin 3.9.15 eller nyare kan testkaraktären trycka på tangenter, till exempel hålla Shift och kontrollera att WalkSpeed ökade. Den bestämmer själv när speltester ska köras, upp till 2 per bygge plus 1 för att kontrollera sin rättelse, och kontrollerar bara det den själv valt att testa, så prova sprint, dash och dubbelhopp själv, och kontrollera mobilknapparna i Device Simulator i Studio. Rörelse är ett system av många i ett spel; att skapa ett helt spel med RoCode går till ett system per prompt, precis som här. Så ansluter RoCode till Studio.

Vanliga frågor

Varför fungerar inte sprintskriptet på mobilen?

En telefon har ingen Shift-tangent. Bind sprinten med ContextActionService:BindAction och skicka true som tredje argument: det lägger till en knapp på skärmen på pekenheter, precis som både ShiftToSprint och MovementClient gör.

Måste sprinten göras på servern?

Nej. Varje enhet flyttar sin egen karaktär, så en WalkSpeed som servern sätter stoppar inte en fuskare som kan sätta sin egen, och den nya hastigheten kommer först efter vägen fram och tillbaka, så sprinten startar med en fördröjning. Gör sprinten på klienten och kontrollera på servern hur långt karaktärerna faktiskt rör sig, som i steg 5. Robloxs beta server authority fungerar annorlunda, och rörelsekoden måste skrivas om för den.

Varför fortsätter karaktären att springa när jag släppt Shift?

Skriptet missade släppet, oftast för att det bara lyssnar på trycket. ContextActionService skickar End när tangenten släpps och Cancel när en annan bindning tar över den; MovementClient stannar vid båda, och dessutom när staminan tar slut eller karaktären slutar röra sig.

Hur lägger jag till en sprintanimation?

Ladda en löpanimation via Animator i karaktärens Humanoid i samma LocalScript, starta den när sprinten börjar och stoppa den när den slutar. Ge den prioriteten Movement. Animationer som spelas på din egen karaktär ser alla.

Varför utlöses dubbelhoppet av sig självt på mobilen?

En nedhållen hoppknapp på mobilen fortsätter att begära hopp. Räkna ett hopp som nytt bara om förfrågningarna har upphört ett ögonblick, som skriptet DoubleJump gör.

Vilken är standardgånghastigheten i Roblox?

16 studs per sekund. Den kommer från StarterPlayer.CharacterWalkSpeed, som sätter Humanoid.WalkSpeed för varje ny karaktär. Sprinten i den här guiden lägger till 10, så sprinten går i 26.

Hur snabb ska sprinten vara i Roblox?

De flesta spel lägger till mellan en halv och en hel gånghastighet: 16 blir något mellan 24 och 32. En kort, långsam sprint passar skräckspel, och en lång, snabb passar stora kartor. Förinställningarna per speltyp ger gånghastighet, sprintbonus och staminasiffror för varje.

Hur gör jag sprint med stamina?

Spara ett staminatal på spelarens enhet, förbruka det varje bildruta under sprint och återhämta det efter en kort vila, båda gångerna med hänsyn till bildrutans tid, och stoppa sprinten när det når 0. MovementClient från steg 3 gör det med en mätare på skärmen; siffrorna ligger i MovementConfig.

Hur sprintar jag med handkontroll i Roblox?

Bind handkontrollens ButtonL3 (tryck på vänster spak) med ContextActionService tillsammans med Left Shift, som båda skripten här gör. ShiftToSprint gör L3 till en växlare, eftersom det är tröttsamt att hålla spaken nedtryckt och samtidigt styra med den.

Krockar sprint med Shift med Shift Lock?

Det kan den. Spelare som har slagit på Shift Lock i Robloxs inställningar växlar det med Shift-tangenten, så samma tangent gör två saker. Robloxs dokumentation säger att API:erna för Shift Lock fasas ut. Om krocken stör dina spelare, stäng av StarterPlayer.EnableMouseLockOption eller bind sprinten i MovementClient till en annan tangent, till exempel Left Ctrl.

Källor och vidare läsning

Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.