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
Slik virker sprint i Roblox
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.
| Element | Hvor det ligger | Hva det gjør |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Steg 1 alene: sprint på tastatur, mobil og gamepad, uten stamina. Når du legger til stamina og dash, erstattes det av MovementClient. |
ModuleScript MovementConfig | ReplicatedStorage | Tallene: sprintbonus, stamina og dash. Både LocalScriptet og sjekken på serveren leser dem. |
LocalScript MovementClient | StarterPlayerScripts | Binder 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 DoubleJump | StarterCharacterScripts | Gir ett ekstra hopp i luften. En ny kopi starter i hver ny karakter. |
Script MovementCheck | ServerScriptService | Må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. |
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.
- I Explorer folder du ut StarterPlayer, holder musen over StarterPlayerScripts, klikker på knappen + og setter inn et LocalScript med navnet
ShiftToSprint. - Erstatt innholdet med koden nedenfor, og trykk på Play.
-- 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?
| Enhet og input | Virker som | Hvorfor |
|---|---|---|
| Tastatur: Left Shift | Hold | Det 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) | Veksle | Det er slitsomt å holde stikken inne og samtidig styre med den. |
| Mobil eller nettbrett: Sprint-knappen på skjermen | Veksle | En 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.
- I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og setter inn et ModuleScript.
- Gi det nytt navn til
MovementConfig, og erstatt innholdet med koden nedenfor.
-- 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
| Innstilling | Verdi | Effekt |
|---|---|---|
SPRINT_BONUS | 10 | Legges til WalkSpeed under sprint. WalkSpeed i Roblox er 16 som standard, så sprint går med 26 studs i sekundet. |
MAX_STAMINA | 100 | En full bar. |
DRAIN_PER_SECOND | 20 | En full bar holder til 5 sekunders sprint. |
REGEN_PER_SECOND | 15 | En tom bar fylles opp på omtrent 6.7 sekunder. |
REGEN_DELAY | 1 | Sekunder med hvile før stamina begynner å komme tilbake. |
MIN_TO_START | 20 | Stamina som kreves for å starte en sprint. |
DASH_SPEED | 60 | Studs i sekundet under en dash. |
DASH_SECONDS | 0.2 | Hvor lenge en dash varer: omtrent 12 studs ved 60 studs i sekundet. |
DASH_COST | 25 | Stamina per dash. |
DASH_COOLDOWN | 1 | Sekunder 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.
- I Explorer folder du ut StarterPlayer, holder musen over StarterPlayerScripts og setter inn et LocalScript med navnet
MovementClient. - Erstatt innholdet med koden nedenfor.
-- 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.
- I Explorer folder du ut StarterPlayer, holder musen over StarterCharacterScripts og setter inn et LocalScript med navnet
DoubleJump. - Erstatt innholdet med koden nedenfor.
-- 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.
- Hold musen over ServerScriptService, og sett inn et Script med navnet
MovementCheck. - Erstatt innholdet med koden nedenfor.
-- 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.
| Jukseren | Hva MovementCheck gjør |
|---|---|
| Setter WalkSpeed til 100 | Advarer etter omtrent ett sekunds løping |
| Setter WalkSpeed til 50 | Advarer 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 gangen | Advarer ved neste sjekk |
| Løper med opptil 38 studs i sekundet, omtrent halvannen gang sprinthastigheten | Ingenting: under 38.5 studs i sekundet tømmes bøtta like raskt som den fylles |
| Endrer sin MovementConfig for å få uendelig stamina | Ingenting: sprint med 26 studs i sekundet er tillatt så lenge man vil |
| Flyr, hopper uten begrensning eller går gjennom vegger | Ingenting: 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:
- I rundesystemet rett etter
character:PivotTo(...)istartRound. - I checkpoint-skriptet for obbyer rett etter hver
character:PivotTo(...)som flytter spilleren til checkpointet sitt.
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
- 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.
- Slipp Shift. Etter 1 sekund begynner baren å fylles opp. Til den er en femtedel full, gjør Shift ingenting.
- 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_SPEEDellerDASH_SECONDSi MovementConfig. - 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.
- Hold Space nede gjennom hele hoppet. Det skal gi ett hopp, ikke to, fordi hoppet i luften krever et nytt trykk.
- 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.
- Å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.
- 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.
- 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. - Hvis placen din har
Workspace.PlayerScriptsUseInputActionSystemsatt til Enabled, test dobbelthoppet igjen: Robloxs dokumentasjon sier ikke omJumpRequestoppfø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.
| Spilltype | CharacterWalkSpeed | SPRINT_BONUS (sprinthastighet) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Full sprint | Fra tom til full | Avstand på én bar |
|---|---|---|---|---|---|---|---|
| Denne guiden | 16 | 10 (26) | 20 | 15 | 5 s | 7.7 s | 130 studs |
| Jakt i horror | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 studs |
| Battlegrounds og kamp | 16 | 12 (28) | 15 | 20 | 6.7 s | 6 s | omtrent 187 studs |
| Åpen verden eller simulator | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 studs |
| Obby eller parkour | 16 | 8 (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 tilSPRINT_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 | Hva problemet er | Denne guiden |
|---|---|---|
BodyVelocity for dash | Utdatert: Roblox sier at man skal bruke LinearVelocity i stedet | LinearVelocity i Plane-modus |
Løkke på RunService.RenderStepped | For 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 liv | Heartbeat 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 ujevnt | Forbruk og påfylling hver frame med deltaTime |
UserInputService.InputBegan uten sjekk av chatten | Et trykk på Shift mens man skriver en melding i chatten, starter sprint | ContextActionService, som også legger til en knapp på mobilen |
WalkSpeed = 16 ved slipp eller hver frame | Overskriver enhver annen hastighet, for eksempel en gamepass-fordel | Endrer WalkSpeed bare når sprinten starter og slutter, og legger til på den nåværende verdien |
| Sprint via RemoteEvent, så serveren setter WalkSpeed | Exploitere setter uansett sin egen WalkSpeed, og sprinten starter med en forsinkelse på turen frem og tilbake | Sprint på klienten pluss avstandssjekk på serveren |
Dobbelthopp ved hver JumpRequest | JumpRequest utløses flere ganger for én hoppforespørsel, og en knapp som holdes inne, kan fortsette å be om hopp | Pause 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øringsskjerm | ContextActionService legger til knapper på skjermen på berøringsenheter uten egen enhetssjekk |
Humanoid:LoadAnimation for sprintanimasjon | Utdatert til fordel for Animator:LoadAnimation | Sprintanimasjon 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.
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.
- 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
- Roblox Creator Docs: ContextActionService (på engelsk). BindAction, berøringsknapper, grensen på 7 knapper og hvorfor den i de fleste tilfeller er bedre enn InputBegan
- Roblox Creator Docs: Humanoid (på engelsk). WalkSpeed og merknaden om sikkerhet, MoveDirection, StateChanged og ChangeState med et eksempel på dobbelthopp
- Roblox Creator Docs: LinearVelocity (på engelsk). Plane-modus, tangentakser og MaxForce
- Roblox Creator Docs: Mover constraints (på engelsk). overgang fra den utdaterte BodyVelocity til LinearVelocity
- Roblox Creator Docs: UserInputService (på engelsk). JumpRequest, og hvorfor den trenger debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (på engelsk). hva klienten styrer, avstandssjekker, lekke bøtter og unntak for teleporter
- Roblox Creator Docs: Server authority model (på engelsk). modellen med bevegelse på serveren, BindToSimulation og Workspace-innstillingene den krever
- Roblox Creator Docs: Input Action System (på engelsk). eksempelet Character Sprint med InputAction og InputBinding
- Roblox Creator Docs: Custom abilities (på engelsk). dash-evnen i Character Controller Library
- Roblox Creator Docs: Studio testing modes (på engelsk). Device Simulator og Controller Emulator
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.