Kort fortalt
Læg ét LocalScript i StarterPlayerScripts, der binder handlingen Sprint med ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Mens Shift holdes nede, lægger du 10 til Humanoid.WalkSpeed (16 bliver til 26), og når den slippes, sætter du den tidligere værdi tilbage. Argumentet true tilføjer en Sprint-knap på touchskærme, og i scriptet fra denne guide slår den knap og L3 på gamepad sprint til og fra i stedet for at virke, mens de holdes.
- Læg til den nuværende WalkSpeed i stedet for at sætte 26, så en hastighedsforøgelse fra et gamepass bevares.
- Sprint kører på spillerens enhed. Serveren kan ikke gennemtvinge WalkSpeed; den kan kun måle, hvor langt karakterer flytter sig, og markere hastigheder, som sprint ikke kan forklare.
- En stamina-bjælke, en dash og et dobbelthop efter samme idé tilføjes i trin 2 til 4. Hvor hurtigt og hvor længe der skal sprintes, får du hjælp til i presets efter spiltype med tal til horror, kamp og åben verden.
På denne side
Sådan virker sprint i Roblox
Hver spillers enhed flytter spillerens egen karakter. Tastaturet, controlleren eller touchskærmen bestemmer, hvor karakteren går hen, og Roblox sender resultatet til serveren og til alle andre. Derfor er sprint et LocalScript, der hæver Humanoid.WalkSpeed, mens en tast holdes nede, og det er alt, hvad trin 1 gør. Resten af guiden er det, et større spil har brug for omkring det: en stamina-bjælke, en dash, et dobbelthop og et tjek på serveren mod snydere.
| Element | Hvor det ligger | Hvad det gør |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Trin 1 alene: sprint på tastatur, telefon og gamepad, uden stamina. Når du tilføjer stamina og dash, erstattes det af MovementClient. |
ModuleScript MovementConfig | ReplicatedStorage | Tallene: sprintbonus, stamina og dash. Både LocalScriptet og tjekket på serveren læser dem. |
LocalScript MovementClient | StarterPlayerScripts | Binder Sprint og Dash til en tast, en gamepad-knap og en touchknap, kører stamina-løkken, tegner bjælken og laver dashen. |
LocalScript DoubleJump | StarterCharacterScripts | Giver ét ekstra hop i luften. En ny kopi starter i hver ny karakter. |
Script MovementCheck | ServerScriptService | Måler, hvor langt hver karakter faktisk flytter sig, og skriver en advarsel i Output, når nogen i længere tid bevæger sig hurtigere, end sprint og dash tillader. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Hvis forskellen mellem Script og LocalScript er ny for dig, så forklarer Script, LocalScript og ModuleScript, hvor hver slags kører, og hvorfor.
Trin 1: sprint med Shift i ét LocalScript
Hvis du kun har brug for hurtigere løb, mens Shift holdes nede, er dette ene script nok. Det giver også telefoner en Sprint-knap på skærmen og lader dig sprinte med venstre stick på en gamepad.
- I Explorer folder du StarterPlayer ud, holder musen over StarterPlayerScripts, klikker på knappen + og indsætter et LocalScript med navnet
ShiftToSprint. - Erstat indholdet med koden nedenfor, og tryk på Play.
-- LocalScript i StarterPlayer > StarterPlayerScripts med navnet ShiftToSprint.
-- Hold Left Shift nede for at sprinte. På en gamepad trykker du på venstre stick (L3) for at
-- slå sprint til eller fra. På en telefon trykker du på Sprint-knappen for at slå den til eller fra.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Indstillinger
local SPRINT_BONUS = 10 -- lægges til WalkSpeed under sprint (16 bliver til 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: knappen skal holdes nede
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- den WalkSpeed, der skal vendes tilbage til
local function getHumanoid(): Humanoid?
local character = player.Character
return character and character:FindFirstChildOfClass("Humanoid")
end
local function setSprinting(on: boolean)
local humanoid = getHumanoid()
if not humanoid or on == sprinting then
return
end
sprinting = on
if on then
-- Husk den nuværende hastighed, og læg til den, så en forøgelse fra et andet script bevares
normalSpeed = humanoid.WalkSpeed
humanoid.WalkSpeed = normalSpeed + SPRINT_BONUS
else
humanoid.WalkSpeed = normalSpeed
end
end
local function onSprint(_name: string, state: Enum.UserInputState, input: InputObject): Enum.ContextActionResult
local isKeyboard = input.UserInputType == Enum.UserInputType.Keyboard
if isKeyboard or not TOGGLE_ON_TOUCH_AND_GAMEPAD then
-- Hold: sprint, mens tasten eller knappen er trykket ned
if state == Enum.UserInputState.Begin then
setSprinting(true)
elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
setSprinting(false)
end
elseif state == Enum.UserInputState.Begin then
-- Skift: hvert tryk slår sprint til eller fra
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Ét kald binder tasten, gamepad-knappen og, på touchskærme, en knap på skærmen
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- En ny karakter starter med at gå: dens Humanoid har allerede den normale WalkSpeed
player.CharacterAdded:Connect(function()
sprinting = false
end)
Ændr SPRINT_BONUS for at gøre sprinten hurtigere eller langsommere. Sæt TOGGLE_ON_TOUCH_AND_GAMEPAD til false, så knappen på telefonen og L3 virker som Shift: sprint kun, mens de holdes nede.
BindAction binder én handling til Left Shift og til L3-knappen på gamepad, og dens tredje argument, true, tilføjer en knap på touchskærme; SetTitle skriver "Sprint" på den. Handleren får også selve inputtet, så den kan skelne et tryk på tastaturet fra en gamepad eller en touchknap. Når sprinten starter, husker scriptet den nuværende WalkSpeed og lægger SPRINT_BONUS til; når den slutter, sætter det den huskede værdi tilbage. En hastighed, som et andet script har sat, for eksempel Speed-fordelen fra gamepass-guiden, bevares. En ny karakter starter med den normale WalkSpeed, så CharacterAdded-handleren nulstiller kun flaget.
Hold eller skift?
| Enhed og input | Virker som | Hvorfor |
|---|---|---|
| Tastatur: Left Shift | Hold | Det er nemt at holde tasten nede, mens man bevæger sig, og når den slippes, stopper sprinten med det samme. |
| Gamepad: tryk på venstre stick (L3) | Skift | Det er trættende at holde sticken trykket ind og samtidig styre med den. |
| Telefon eller tablet: Sprint-knappen på skærmen | Skift | En tommelfinger, der holder knappen, kan ikke samtidig trykke på Jump. |
For at teste trykker du på Play og holder Shift nede, mens du går: hastigheden stiger fra 16 til 26 studs i sekundet, og hvis du slipper, sætter du farten ned. Til telefon vælger du en telefon i Device Simulator i Studio, trykker på Play og trykker på Sprint én gang for at starte og én gang til for at stoppe. Til gamepad åbner du Controller Emulator under en playtest og trykker på L3. Den fulde liste over tjek pr. enhed findes i trin 6.
Trin 2 og 3 erstatter dette script med et andet med stamina-bjælke og dash. Trin 4 og 5 tilføjer dobbelthop og tjekket på serveren og virker med begge scripts.
Trin 2: tallene for stamina og dash i ét modul
Til en sprint, der løber tør, skifter trin 2 og 3 ShiftToSprint ud med et større LocalScript med stamina-bjælke og dash. Slet først ShiftToSprint: begge scripts binder handlingen Sprint.
Alle tallene ligger i ét ModuleScript, så følelsen af bevægelsen justeres ét sted. MovementClient læser dem på hver spillers enhed, og MovementCheck læser det samme modul på serveren for at vide, hvor hurtig sprint og dash skal være.
- I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og indsætter et ModuleScript.
- Omdøb det til
MovementConfig, og erstat indholdet med koden nedenfor.
-- Ét sæt tal til bevægelses-LocalScriptet og hastighedstjekket på serveren.
local MovementConfig = {
SPRINT_BONUS = 10, -- lægges til den nuværende WalkSpeed: 16 (Robloxs standard) bliver til 26
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 sekunders sprint fra en fuld bjælke
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- sekunder efter sprintens slutning, før stamina begynder at komme tilbage
MIN_TO_START = 20, -- den stamina, der kræves for at starte en sprint, så en tom bjælke ikke blinker
DASH_SPEED = 60, -- studs i sekundet under en dash
DASH_SECONDS = 0.2, -- så dækker en dash omkring 12 studs
DASH_COST = 25, -- stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Indstilling | Værdi | Effekt |
|---|---|---|
SPRINT_BONUS | 10 | Lægges til WalkSpeed under sprint. WalkSpeed i Roblox er som standard 16, så sprint går med 26 studs i sekundet. |
MAX_STAMINA | 100 | En fuld bjælke. |
DRAIN_PER_SECOND | 20 | En fuld bjælke rækker til 5 sekunders sprint. |
REGEN_PER_SECOND | 15 | En tom bjælke fyldes op på cirka 6.7 sekunder. |
REGEN_DELAY | 1 | Sekunders hvile, før stamina begynder at komme tilbage. |
MIN_TO_START | 20 | Den stamina, der kræves for at starte en sprint. |
DASH_SPEED | 60 | Studs i sekundet under en dash. |
DASH_SECONDS | 0.2 | Hvor længe en dash varer: omkring 12 studs ved 60 studs i sekundet. |
DASH_COST | 25 | Stamina pr. dash. |
DASH_COOLDOWN | 1 | Sekunder mellem dashes. |
Hver side kører sin egen kopi af modulet (et modul køres én gang på hver side), så en spiller, der ændrer disse tal på sin enhed, ændrer kun sin egen kopi. Men her beskytter det ikke noget: spillerens enhed flytter alligevel karakteren og kan give sig selv uendelig stamina, uanset hvad der står i modulet. Tjekket på serveren i trin 5 er bygget med det i tankerne.
Trin 3: sprint med stamina og dash
Dette LocalScript laver det, spillerne mærker. Det binder Sprint og Dash, tegner stamina-bjælken, kører stamina-løkken hvert frame og laver dashen.
- I Explorer folder du StarterPlayer ud, holder musen over StarterPlayerScripts og indsætter et LocalScript med navnet
MovementClient. - Erstat indholdet med koden nedenfor.
-- Hold Shift (eller L3, eller Sprint-knappen på telefonen) nede for at sprinte, så længe der er stamina.
-- Tryk på Q (eller B, eller Dash-knappen) for at lave en dash i bevægelsesretningen.
local ContextActionService = game:GetService("ContextActionService")
local Debris = game:GetService("Debris")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
type Config = {
SPRINT_BONUS: number,
MAX_STAMINA: number,
DRAIN_PER_SECOND: number,
REGEN_PER_SECOND: number,
REGEN_DELAY: number,
MIN_TO_START: number,
DASH_SPEED: number,
DASH_SECONDS: number,
DASH_COST: number,
DASH_COOLDOWN: number,
}
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config
local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- den WalkSpeed, der skal vendes tilbage til, når sprinten slutter
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Stamina-bjælken: en ramme med en udfyldning, hvis bredde svarer til den resterende stamina
local gui = Instance.new("ScreenGui")
gui.Name = "StaminaGui"
gui.ResetOnSpawn = false
local bar = Instance.new("Frame")
bar.AnchorPoint = Vector2.new(0.5, 1)
bar.Position = UDim2.new(0.5, 0, 1, -24)
bar.Size = UDim2.fromOffset(240, 14)
bar.BackgroundColor3 = Color3.fromRGB(30, 26, 40)
bar.Parent = gui
local fill = Instance.new("Frame")
fill.Size = UDim2.fromScale(1, 1)
fill.BackgroundColor3 = Color3.fromRGB(80, 220, 150)
fill.BorderSizePixel = 0
fill.Parent = bar
for _, frame in { bar, fill } do
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(1, 0)
corner.Parent = frame
end
gui.Parent = player:WaitForChild("PlayerGui")
local function getHumanoid(): Humanoid?
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if humanoid and humanoid.Health > 0 then
return humanoid
end
return nil
end
-- Sprint: her kun et flag; Heartbeat-løkken nedenfor afgør hvert frame, om der skal sprintes
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Kun tryk og slip ændrer det: en finger, der glider over touchknappen, sender Change
if state == Enum.UserInputState.Begin then
sprintHeld = true
elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
sprintHeld = false
end
return Enum.ContextActionResult.Pass
end
local function dash()
local humanoid = getHumanoid()
local rootPart = humanoid and humanoid.RootPart
local now = os.clock()
-- Ingen dash, mens man sidder: en siddende karakter er svejset til sædet, så den ville skubbe hele køretøjet
if not (humanoid and rootPart) or humanoid.Sit or now - lastDashTime < Config.DASH_COOLDOWN or stamina < Config.DASH_COST then
return
end
local attachment = rootPart:FindFirstChild("RootAttachment")
if not (attachment and attachment:IsA("Attachment")) then
return
end
lastDashTime = now
stamina -= Config.DASH_COST
lastSprintTime = now -- sæt genopfyldningen på pause, ligesom sprint gør
-- Dash derhen, hvor spilleren bevæger sig, eller derhen, hvor den kigger, hvis den står stille
local direction = humanoid.MoveDirection
if direction.Magnitude < 0.1 then
direction = rootPart.CFrame.LookVector
end
direction = Vector3.new(direction.X, 0, direction.Z).Unit
-- LinearVelocity i Plane-tilstand holder den vandrette hastighed og lader tyngdekraften være
local velocity = Instance.new("LinearVelocity")
velocity.Attachment0 = attachment
velocity.RelativeTo = Enum.ActuatorRelativeTo.World
velocity.VelocityConstraintMode = Enum.VelocityConstraintMode.Plane
velocity.PrimaryTangentAxis = Vector3.xAxis
velocity.SecondaryTangentAxis = Vector3.zAxis
velocity.PlaneVelocity = Vector2.new(direction.X, direction.Z) * Config.DASH_SPEED
velocity.MaxForce = math.huge
velocity.Parent = rootPart
Debris:AddItem(velocity, Config.DASH_SECONDS)
end
local function onDash(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
if state == Enum.UserInputState.Begin then
dash()
end
return Enum.ContextActionResult.Pass
end
-- Hvert kald binder en tast, en gamepad-knap og, på touchenheder, en knap på skærmen
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:BindAction("Dash", onDash, true, Enum.KeyCode.Q, Enum.KeyCode.ButtonB)
ContextActionService:SetTitle("Sprint", "Sprint")
ContextActionService:SetTitle("Dash", "Dash")
-- Hvert frame: brug stamina under sprint og bevægelse, fyld op efter en kort hvile
RunService.Heartbeat:Connect(function(deltaTime: number)
local humanoid = getHumanoid()
if not humanoid then
return
end
local moving = humanoid.MoveDirection.Magnitude > 0
local now = os.clock()
local enoughStamina = if sprinting then stamina > 0 else stamina >= Config.MIN_TO_START
local shouldSprint = sprintHeld and moving and enoughStamina
-- Ændr kun WalkSpeed ved sprintens start og slutning, så en hastighed, som et andet
-- script har sat (for eksempel et speed-pass), bevares, og sprinten lægges oven i den
if shouldSprint and not sprinting then
sprinting = true
normalSpeed = humanoid.WalkSpeed
humanoid.WalkSpeed = normalSpeed + Config.SPRINT_BONUS
elseif not shouldSprint and sprinting then
sprinting = false
humanoid.WalkSpeed = normalSpeed
end
if sprinting then
stamina = math.max(0, stamina - Config.DRAIN_PER_SECOND * deltaTime)
lastSprintTime = now
elseif now - lastSprintTime >= Config.REGEN_DELAY then
stamina = math.min(Config.MAX_STAMINA, stamina + Config.REGEN_PER_SECOND * deltaTime)
end
fill.Size = UDim2.fromScale(stamina / Config.MAX_STAMINA, 1)
end)
-- En ny karakter starter med fuld stamina, og intet holdes nede
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- en ny Humanoid starter med den normale WalkSpeed
end)
Stamina-bjælken oprettes i koden med ResetOnSpawn sat til false, så den bliver på skærmen efter respawn, og CharacterAdded-handleren nederst fylder den op igen for hver ny karakter. Linjerne med type Config beskriver, hvad modulet returnerer, så streng typekontrol fanger en tastefejl i et indstillingsnavn; under spillet ændrer de ingenting.
Tastatur, gamepad og knap på telefonen med ét kald
ContextActionService:BindAction tager handlingens navn, en handlerfunktion, om der skal oprettes en touchknap, og derefter inputs. Hvis du sender true som tredje argument, tilføjer ContextActionService en knap på skærmen på touchenheder, inde i en ScreenGui med navnet ContextActionGui i spillerens PlayerGui. SetTitle skriver "Sprint" og "Dash" på knapperne. BindAction kan højst oprette 7 touchknapper, så hold øje med antallet, hvis andre scripts i spillet også bruger dem.
Handleren får inputtets tilstand: Begin ved tryk og End ved slip. onSprint husker kun, om Sprint holdes nede. Den regner også Cancel som et slip, som ContextActionService sender, når en anden binding overtager inputtet, og ignorerer Change, som en finger, der bevæger sig over touchknappen, kan sende. Begge handlere returnerer Pass, så den næste binding på samme tast også får inputtet.
Roblox-referencen for ContextActionService anbefaler den frem for UserInputService.InputBegan i de fleste tilfælde. Dens eksempel: et bilhorn på H, der ikke skal dytte, mens spilleren skriver i chatten. En binding udløses kun, så længe den er den seneste for det input, så når chatten overtager tastaturet, behøver du ikke at tjekke noget. Gamepad-inputs: ButtonL3 (tryk på venstre stick, som holdes under bevægelse) og ButtonB. Robloxs eget sprint-eksempel bruger ButtonY, så skift KeyCode i BindAction, hvis det passer bedre til dit spil.
Stamina-løkken
RunService.Heartbeat udløses hvert frame efter fysiktrinnet og sender deltaTime, antallet af sekunder siden sidste frame. Hvis du ganger forbrugs- og genopfyldningshastigheden med den, rækker en fuld bjælke til 5 sekunder, uanset om spillet kører med 30 eller 240 frames i sekundet.
Hvert frame afgør løkken, om karakteren skal sprinte: Sprint holdes nede, karakteren går (Humanoid.MoveDirection er nulvektoren, når den står stille), og der er stadig stamina. For at starte en sprint kræves mindst MIN_TO_START (20); for at fortsætte er alt over 0 nok. Uden denne margin ville en tom bjælke, der fyldes en lille smule hvert frame, slå sprint til og fra hvert frame. Genopfyldningen starter REGEN_DELAY (1 sekund) efter den seneste sprint eller dash, så når spilleren har tømt bjælken, venter den omkring 2.3 sekunder, før den kan sprinte igen.
WalkSpeed ændres kun i det frame, hvor sprinten starter eller slutter. Ved start husker scriptet den nuværende WalkSpeed og lægger SPRINT_BONUS til; ved slut sætter det den huskede værdi tilbage. Derfor bevares en hastighed, som et andet script har sat: Speed-fordelen fra gamepass-guiden sætter WalkSpeed til 24, og med dette script sprinter dens ejere med 34. Et script, der skriver WalkSpeed = 16 hvert frame eller ved hvert slip, ville ubemærket annullere den fordel.
Dash
En dash skubber karakteren derhen, hvor den bevæger sig, eller derhen, hvor den kigger, hvis den står stille, og retningen gøres vandret, så den aldrig peger op eller ned. Den koster 25 stamina, sætter genopfyldningen på pause ligesom sprint og har en cooldown på 1 sekund. Den tjekker ikke for jord, så den virker også i luften, hvilket passer godt med dobbelthop. Mens karakteren sidder, gør dashen ingenting: en siddende karakter er svejset til sædet, og i et køretøj kunne skubbet flytte hele køretøjet.
Skubbet er en LinearVelocity-constraint på rodpartens RootAttachment. I Plane-tilstand med akserne X og Z holder den en vandret hastighed på 60 studs i sekundet og rører ikke den lodrette, så tyngdekraften virker, og en dash ud over en kant falder som normalt. MaxForce er math.huge, så skubbet er ubegrænset. Debris:AddItem destruerer constrainten efter DASH_SECONDS uden at få scriptet til at vente, så dashen varer 0.2 sekund, omkring 12 studs ved den hastighed.
Gamle tutorials bruger BodyVelocity, som Roblox har markeret som forældet med besked om at bruge LinearVelocity i stedet. Dens trick med MaxForce på nul langs én akse erstattes af tilstandene Line, Plane og Vector på LinearVelocity. Da spillerens enhed selv simulerer sin karakter, flytter en constraint, der er oprettet af et LocalScript, karakteren, og andre spillere ser dashen som enhver anden bevægelse.
Robloxs egen UI-tutorial fastgør constrainten til humanoid.RootPart.RootAttachment på præcis samme måde. Hvis dit spil har en egen karakter, hvis rodpart ikke har en Attachment med navnet RootAttachment, gør dashen ingenting: tilføj den til HumanoidRootPart i din StarterCharacter.
Trin 4: dobbelthop
Dobbelthoppet bor i sit eget LocalScript i StarterCharacterScripts. Roblox lægger en kopi af scripts fra den container i hver karakter ved spawn, og de kopier overlever ikke respawn, så hvert liv starter med et frisk script, og intet overføres fra det forrige.
- I Explorer folder du StarterPlayer ud, holder musen over StarterCharacterScripts og indsætter et LocalScript med navnet
DoubleJump. - Erstat indholdet med koden nedenfor.
-- Giver ét ekstra hop i luften. Starter forfra for hver ny karakter,
-- så intet overføres efter respawn.
local UserInputService = game:GetService("UserInputService")
local character = script.Parent :: Model
local humanoid = character:WaitForChild("Humanoid") :: Humanoid
local EXTRA_JUMPS = 1
local MIN_SECONDS_BETWEEN_JUMPS = 0.25 -- JumpRequest udløses flere gange for ét tryk
local NEW_PRESS_GAP = 0.1 -- en holdt hopknap bliver ved med at sende JumpRequest; en pause af denne længde betyder, at den er sluppet
local jumpsLeft = 0
local lastJump = 0
local lastRequest = 0
humanoid.StateChanged:Connect(function(oldState: Enum.HumanoidStateType, newState: Enum.HumanoidStateType)
if newState == Enum.HumanoidStateType.Jumping and oldState ~= Enum.HumanoidStateType.Freefall then
-- Et hop fra jorden (ikke et af vores hop i luften) giver hop i luften tilbage
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- JumpRequest udløses, når spilleren beder om et hop, for eksempel med Space eller hopknappen på telefonen
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Kun et nyt tryk hopper igen, så en holdt knap ikke bruger hoppet i luften
if not newPress or jumpsLeft <= 0 or now - lastJump < MIN_SECONDS_BETWEEN_JUMPS then
return
end
if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
jumpsLeft -= 1
lastJump = now
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
end)
Sæt EXTRA_JUMPS til 2 for et tredobbelt hop.
Scriptet følger karakterens tilstand via Humanoid.StateChanged. Et skift til Jumping, der ikke kom fra Freefall, er et hop fra jorden, så det giver et hop i luften, og Landed tager det igen. Hvis man går ud over en kant, kommer karakteren i Freefall uden hop, så den får intet hop i luften. Hvis du også vil have det der, så sæt jumpsLeft også ved skift til Freefall fra enhver tilstand undtagen Jumping.
UserInputService.JumpRequest udløses, når spilleren beder om et hop, for eksempel med Space eller hopknappen på telefonen. Roblox-referencen advarer om, at den udløses flere gange for én hopforespørgsel, og anbefaler debounce, så scriptet ignorerer forespørgsler i 0.25 sekund efter det seneste hop. En holdt hopknap kan også blive ved med at bede om hop og ville bruge hoppet i luften i samme øjeblik, som karakteren letter fra jorden, så en forespørgsel tæller kun som et nyt tryk efter 0.1 sekund uden forespørgsler.
Selve hoppet i luften er Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Roblox-referencen siger, at det skal kaldes fra et LocalScript på den enhed, der har network ownership over karakteren, og som standard er det spillerens egen enhed, ikke serveren. Kodeeksemplet til ChangeState i referencen er netop et dobbelthop.
Trin 5: fang speedhacks på serveren
Sprint-tutorials stopper ofte ved klienten. Et server-Script kan ikke stole på spillerens WalkSpeed, fordi exploitere ændrer den på deres enhed, men det kan se, hvor deres karakter ender. MovementCheck måler det to gange i sekundet og skriver en advarsel i Output, når nogen i længere tid bevæger sig hurtigere, end sprint og dash tillader. Tallene for sprint og dash læser det fra MovementConfig, så tilføj det modul fra trin 2, selv om du har beholdt ShiftToSprint.
- Hold musen over ServerScriptService, og indsæt et Script med navnet
MovementCheck. - Erstat indholdet med koden nedenfor.
-- Spillernes enheder flytter deres egne karakterer, så en exploiter kan sætte en hvilken som helst WalkSpeed.
-- Dette tjek måler, hvor langt hver karakter faktisk flytter sig, og skriver i Output,
-- når nogen i længere tid bevæger sig hurtigere, end sprint og dash tillader. Det advarer kun:
-- lag, teleporter og transportbånd kan ligne for høj hastighed, så justér det, før du straffer nogen.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local StarterPlayer = game:GetService("StarterPlayer")
type Config = { SPRINT_BONUS: number, DASH_SPEED: number, DASH_SECONDS: number }
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config
local CHECK_EVERY = 0.5 -- sekunder
-- Sprinthastighed plus margin til lag. Hæv den, hvis du sælger hastighedsforøgelser.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- margin til en eller to dashes
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- hvor hurtigt tidligere dashes tilgives
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- den rodpart, lastPosition er målt på
local excess: { [Player]: number } = {} -- studs over tolerancen, tilgives gradvist
Players.PlayerRemoving:Connect(function(player: Player)
lastPosition[player] = nil
lastRoot[player] = nil
excess[player] = nil
end)
while true do
task.wait(CHECK_EVERY)
for _, player in Players:GetPlayers() do
local character = player.Character
local rootPart = character and character:FindFirstChild("HumanoidRootPart")
if rootPart and rootPart:IsA("BasePart") then
local position = rootPart.Position
-- En respawn er en ny rodpart, og en teleport på serveren (rundestart, checkpoint)
-- sætter attributten nedenfor: begynd at måle forfra i stedet for at markere springet
local previous = if lastRoot[player] == rootPart then lastPosition[player] else nil
if player:GetAttribute("MovementCheckSkip") then
player:SetAttribute("MovementCheckSkip", nil)
previous = nil
end
lastPosition[player] = position
lastRoot[player] = rootPart
if previous then
-- Kun vandret bevægelse: at falde hurtigt er ikke snyd
local moved = Vector3.new(position.X - previous.X, 0, position.Z - previous.Z).Magnitude
local extra = moved - SPEED_ALLOWANCE * CHECK_EVERY
local total = math.max(0, (excess[player] or 0) + extra - DRAIN_PER_CHECK)
excess[player] = total
if total > BURST_ALLOWANCE then
warn(`MovementCheck: {player.Name} moved {math.round(moved / CHECK_EVERY)} studs/s`)
excess[player] = 0
end
end
else
lastPosition[player] = nil
lastRoot[player] = nil
end
end
end
Advarslen vises i Output i Studio. I det live spil havner den i serverloggen i Developer Console, som du kan læse som spillets ejer: se output i det live spil.
Hvad det måler
Hvert halve sekund læser scriptet positionen af hver karakters rodpart og måler, hvor langt den har flyttet sig vandret siden sidste tjek. Højden ignoreres, så fald og hop tæller aldrig med; Robloxs råd om bevægelsestjek foreslår den samme projektion på XZ-planet til spil, hvor man går på jorden. Tolerancen er standardganghastigheden plus sprintbonussen og en fjerdedel mere til lag: 32.5 studs i sekundet. Afstand ud over det havner i en "utæt spand", en akkumulator, som Robloxs dokumentation siger passer mange udviklere godt til korte ryk. Spanden mister 3 studs ved hvert tjek, og scriptet advarer, når den indeholder mere end 24 studs, hvilket er en margin på cirka to dashes.
| Snyder | Hvad MovementCheck gør |
|---|---|
| Sætter WalkSpeed til 100 | Advarer efter cirka et sekunds løb |
| Sætter WalkSpeed til 50 | Advarer efter cirka 2.5 sekunders løb |
| Laver dashes i træk uden cooldown (60 studs i sekundet) | Advarer efter cirka 1.5 sekund |
| Teleporterer mere end 43 studs ad gangen | Advarer ved næste tjek |
| Løber med op til 38 studs i sekundet, cirka halvanden gang sprinthastigheden | Intet: under 38.5 studs i sekundet tømmes spanden lige så hurtigt, som den fyldes |
| Ændrer sin MovementConfig for at få uendelig stamina | Intet: sprint med 26 studs i sekundet er tilladt så længe, man vil |
| Flyver, hopper uden begrænsning eller går gennem vægge | Intet: tjekket ignorerer højden og ser ikke på kollisioner |
Så tjekket fanger grov snyd, hvor en spiller er tydeligt hurtigere end alle andre, og lader den forsigtige slippe igennem. Det er den ærlige grænse for et afstandstjek og grunden til, at Roblox laver noget stærkere (se server authority nedenfor).
Hvorfor det kun advarer
Robloxs dokumentation nævner, at simple hastighedstjek kan markere ærlige spillere med en ustabil forbindelse og går i stykker i spil med køretøjer eller anden kompleks bevægelse. Lagspring, transportbånd, køretøjer, eksplosioner, der kaster karakterer væk, og dine egne teleporter kan ligne for høj hastighed, så scriptet skriver kun en advarsel. Hold øje med Output, mens du og dine testere spiller som normalt, hæv SPEED_ALLOWANCE, hvis ærlige spillere snubler over den, og tilføj en straf, for eksempel at sætte spilleren tilbage, først når tjekket er tavst i almindeligt spil. Hvis eksplosioner i dit spil kaster karakterer væk, så spring også spillere over, hvis Humanoid ikke har mere liv.
Respawns og teleporter
En respawn opretter en ny rodpart, og scriptet begynder at måle forfra, når det ser den, så at dø langt fra spawnpunktet tæller aldrig som for høj hastighed. Teleporter, som dine egne server-scripts laver, har brug for en undtagelse, som Robloxs dokumentation siger om ethvert spil med teleporter. Efter en teleport tilføjer du player:SetAttribute("MovementCheckSkip", true), så begynder næste tjek at måle fra den nye position i stedet for at markere springet:
- I rundesystemet lige efter
character:PivotTo(...)istartRound. - I checkpoint-scriptet til obbies lige efter hver
character:PivotTo(...), der flytter spilleren til sit checkpoint.
Pladerne og menuen fra teleport-guiden og Finish-pladen fra guiden til dit første spil sætter den allerede efter hver flytning.
Kun værdien fra serveren tæller. En attribut, som spilleren sætter på sin enhed, bliver på den enhed (se hvad der replikeres, og hvad der ikke gør), så en snyder kan ikke slå tjekket fra med den.
Løsningen for fremtiden: server authority
Robloxs sikkerhedsdokumentation kalder modellen server authority, i skrivende stund i beta, den mest pålidelige måde at stoppe bevægelses-exploits på. Serveren bliver kilden til sandheden, og spillernes enheder sender kun deres input, hvilket ifølge dokumentationen forhindrer speedhacks i at virke, fordi enheden aldrig får lov til selv at melde sin position.
Overgangen er en omskrivning, ikke en justering. I den model beregner serveren bevægelsen, så WalkSpeed eller LinearVelocity, som kun et LocalScript sætter, annulleres, når tilstanden fra serveren kommer. I Robloxs dokumentation står der, at hovedlogikken skal køre i RunService:BindToSimulation()-funktioner i et ModuleScript, som både klienten og serveren kører. Modellen kræver også nogle Workspace-indstillinger, herunder PlayerScriptsUseInputActionSystem, så din styring flytter også over på Input Action System. Behold versionen fra denne guide, indtil du har flyttet sprint, stamina og dash over i den opbygning. Indtil da er et afstandstjek som dette netop det, Robloxs afsnit om bevægelsestjek beskriver.
Trin 6: test på hver enhed
- Tryk på Play, og hold Shift nede, mens du går. Hastigheden stiger fra 16 til 26 studs i sekundet, og den grønne bjælke nederst på skærmen bliver mindre. Efter cirka 5 sekunder er den tom, og du går igen.
- Slip Shift. Efter 1 sekund begynder bjælken at fylde op. Indtil den er en femtedel fuld, gør Shift ingenting.
- Tryk på Q, mens du går: du suser et stykke fremad, og en fjerdedel af bjælken er væk. Tryk på Q igen med det samme, og der sker ingenting, før der er gået et sekund. Hvis dashen føles for kort eller for lang, så ændr
DASH_SPEEDellerDASH_SECONDSi MovementConfig. - Hop, og tryk derefter på hop igen i luften for et andet hop. Land, og prøv igen: hvert hop fra jorden giver hoppet i luften tilbage.
- Hold Space nede gennem hele hoppet. Det skal give ét hop, ikke to, fordi hoppet i luften kræver et nyt tryk.
- Slå Device Simulator til i Studio (i skrivende stund en beta: File, Beta Features, New Device Simulator, og genstart derefter Studio), eller slå den gamle Device Emulator til i menuen Test. Vælg en telefon, og tryk på Play. Knapperne Sprint og Dash dukker op. Hold Sprint, mens du styrer, hold derefter hopknappen nede gennem hele hoppet, og tjek, at der kun er ét hop.
- Åbn Controller Emulator (Controller på fanen Emulation eller Virtual controller i Device Simulator-panelet). Hold L3 under bevægelse for at sprinte, tryk på B for en dash og på A to gange for et dobbelthop.
- Nulstil karakteren via spillets menu. Bjælken er fuld igen, der er ingen MovementCheck-advarsel i Output, og hvis du stadig simulerer en telefon, er knapperne Sprint og Dash på plads.
- Spil nu som snyder. Klik på kontakten Client/Server, indtil Explorer viser klienten, markér din karakters Humanoid i Workspace, og sæt WalkSpeed til 60 i Properties-vinduet. Gå rundt i nogle sekunder: i Output dukker en advarsel op som
MovementCheck: YourName moved 60 studs/s. Sæt den tilbage til 16, sprint og lav dashes som normalt i et minut, og tjek, at Output er tavst. - Hvis dit place har
Workspace.PlayerScriptsUseInputActionSystemsat til Enabled, så test dobbelthoppet igen: Robloxs dokumentation siger ikke, omJumpRequestopfører sig på samme måde med den.
Hvis der slet ikke sker noget, så åbn Output-vinduet via menuen Window i Studio, og led efter en rød fejl fra MovementClient, eller kig i almindelige fejl.
Hvor hurtigt og hvor længe: presets efter spiltype
Den rigtige sprint afhænger af spillet. En jagt i et horrorspil har brug for en kort, langsom sprint, der slutter på det værst tænkelige tidspunkt; et stort åbent kort har brug for en lang, så spillerne ikke keder sig på vej over det. Disse presets bruger de samme scripts og ændrer kun ganghastigheden og MovementConfig. Det er vores udgangspunkter, beregnet ud fra indstillingerne, ikke målt på spillere.
| Spiltype | CharacterWalkSpeed | SPRINT_BONUS (sprinthastighed) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Fuld sprint | Fra tom til fuld | Afstand på én bjælke |
|---|---|---|---|---|---|---|---|
| Denne guide | 16 | 10 (26) | 20 | 15 | 5 s | 7.7 s | 130 studs |
| Jagt 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 | omkring 187 studs |
| Åben verden eller simulator | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 studs |
| Obby eller parkour | 16 | 8 (24) | ingen stamina: brug ShiftToSprint |
- Ganghastigheden sættes i StarterPlayer. Markér StarterPlayer, og sæt
CharacterWalkSpeed(standard 16). Hver ny karakter starter med den hastighed, sprint læggerSPRINT_BONUStil, og MovementCheck læser den også, så tjekket på serveren følger dit valg. - MovementCheck tilpasser sig. Det tillader ganghastigheden plus sprintbonussen og en fjerdedel mere til lag: 25 studs i sekundet for horror-presettet, 40 for åben verden. Intet andet skal ændres.
- I et obby ændrer sprint banen. Med hurtigere sprint kan længere huller springes over. Byg hoppene, og tjek derefter hvert ved sprinthastighed, ellers gør sprinten etaperne for lette. Guiden til obby-checkpoints passer godt sammen med ShiftToSprint.
- I horror er dræberen målestokken. Gør forfølgeren lidt hurtigere end ganghastigheden og lidt langsommere end sprint, så flugten afhænger af, hvornår bjælken løber tør. Guiden til horrorspil gennemgår resten af løkken.
Hvad der er galt med gamle sprint-scripts
Gamle tutorials til sprint, dash og dobbelthop virker ofte stadig, men mange bruger tricks, som Roblox siden har erstattet, eller ødelægger andre systemer i dit spil. Hvis du retter et kopieret script, så sammenlign det med denne liste.
| Trick | Hvad problemet er | Denne guide |
|---|---|---|
BodyVelocity til dash | Forældet: Roblox siger, at man skal bruge LinearVelocity i stedet | LinearVelocity i Plane-tilstand |
Løkke på RunService.RenderStepped | Til nyt arbejde er den erstattet af PreRender. Spillogik som stamina hører hjemme på Heartbeat, som Roblox beskriver til periodiske opgaver som genopfyldning af liv | Heartbeat med deltaTime |
Stamina-løkke med wait() | wait() er forældet til fordel for task.wait() og bliver bremset, så den kan vente længere end bedt om, og et fast forbrug pr. wait bruger stamina ujævnt | Forbrug og genopfyldning hvert frame med deltaTime |
UserInputService.InputBegan uden tjek af chatten | Et tryk på Shift, mens man skriver en besked i chatten, starter sprint | ContextActionService, som også tilføjer en knap på telefonen |
WalkSpeed = 16 ved slip eller hvert frame | Overskriver enhver anden hastighed, for eksempel en gamepass-fordel | Ændrer kun WalkSpeed ved sprintens start og slutning og lægger til den nuværende værdi |
| Sprint via RemoteEvent, så serveren sætter WalkSpeed | Exploitere sætter alligevel selv deres WalkSpeed, og sprinten starter med en forsinkelse på turen frem og tilbage | Sprint på klienten plus afstandstjek på serveren |
Dobbelthop ved hver JumpRequest | JumpRequest udløses flere gange for én hopforespørgsel, og en holdt knap kan blive ved med at bede om hop | Pause på 0.25 sekund og tjek af nyt tryk |
UserInputService.TouchEnabled som tjek af "det er en telefon" | Den er true på bærbare med touchskærm | ContextActionService tilføjer knapper på skærmen på touchenheder uden dit eget enhedstjek |
Humanoid:LoadAnimation til sprintanimation | Forældet til fordel for Animator:LoadAnimation | Sprintanimation nedenfor bruger Animator |
Robloxs nye måde: Input Action System
Robloxs side om Input Action System tager karakterens sprint som første eksempel. I stedet for kald til BindAction sættes styringen op i Studio: en InputAction med navnet CharacterSprint inde i en input context i ReplicatedStorage, med én InputBinding til Left Shift, én til knappen Y på gamepad og én knyttet til en knap på skærmen, som du tegner i StarterGui. Derefter lytter et klient-script efter handlingens events Pressed og Released, fordobler WalkSpeed ved tryk og sætter den tilbage ved slip.
Det er værd at skifte til den, hvis du vil lægge styringen ud i Studio i stedet for i koden, have din egen touchknap i stedet for ContextActionServices knap eller have kontekster, der skifter hele sæt af styring, for eksempel til menuer eller køretøjer. Siden anbefaler også at sætte Workspace.PlayerScriptsUseInputActionSystem til Enabled, og server authority kræver det.
Stamina-løkken og dashen fra denne guide virker på samme måde med Input Action System alene (uden server authority). Behold MovementConfig, Heartbeat-løkken og dash(), slet de to kald til BindAction og deres handlere, og forbind handlingerne i stedet: Pressed på sprint-handlingen sætter sprintHeld til true, og dens Released til false, og Pressed på dash-handlingen kalder dash(). Bliv ved med at finde Humanoid hvert frame, som MovementClient gør, fordi eksemplet i dokumentationen gemmer den første karakters Humanoid, og efter en respawn er den væk.
Roblox tester også Character Controller Library, en beta, der slås til under Beta Features og Avatar Settings i Studio. Dens side om egne evner bygger som eksempel en dash med et aktivt vindue på 0.2 sekund og en cooldown på 1 sekund, altså med samme timing som dashen fra denne guide.
Sådan udvider du: animation, kamera og et sprint-pass
Sprintanimation
Lav en løbeanimation i Animation Editor, giv den prioriteten Movement (Roblox anbefaler den til gå- og løbeanimationer), udgiv den, og kopiér asset-ID. I MovementClient opretter du en Animation med det AnimationId, indlæser den med Animator:LoadAnimation ved hjælp af Animator inde i karakterens Humanoid, starter sporet der, hvor sprinten starter, og stopper det der, hvor den slutter. Indlæs den igen for hver ny karakter.
Animationer, som din enhed starter på din karakter, kan ses af alle, hvis du bruger den Animator, Roblox har lagt der: spor, der er indlæst på en Animator oprettet af et LocalScript, replikeres ikke. Humanoid:LoadAnimation, som mange gamle tutorials bruger, er forældet.
Bredere kamera under sprint
En lidt bredere synsvinkel får sprinten til at føles hurtigere. De samme to steder tweener du workspace.CurrentCamera.FieldOfView fra standardværdien 70 til cirka 80, når sprinten starter, og tilbage, når den slutter, for eksempel med TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox begrænser værdien til mellem 1 og 120 og advarer om, at meget lave eller meget høje værdier kan desorientere spillerne. Hvis et andet script i spillet også ændrer synsvinklen, så tween tilbage til den fundne værdi i stedet for til 70.
Hurtig sprint som gamepass
Gamepass-guiden virker allerede med dette script: dens Speed-fordel på serveren sætter WalkSpeed til 24 for hver ny karakter, MovementClient lægger sprintbonussen oveni, og 34 studs i sekundet holder sig inden for det, MovementCheck tillader.
Til et pass, der gør selve sprinten hurtigere, tilføjer du passet FastSprint i PassConfig.ids fra den guide. Dens server-script sætter så attributten OwnsPass_FastSprint på spilleren, så snart købet er bekræftet. I MovementClient bruger du en større bonus end Config.SPRINT_BONUS, når player:GetAttribute("OwnsPass_FastSprint") == true. I MovementCheck giver du sådanne spillere en større tolerance ved at læse den samme attribut på serveren, hvor spilleren ikke kan ændre den, og tjekker, at den nye maksimale hastighed holder sig under det, tjekket markerer.
Én begrænsning, der er god at kende: hvis et andet script ændrer WalkSpeed midt i en sprint, sætter slutningen af den sprint hastigheden tilbage til den, der var før. Den næste respawn sætter passets hastighed igen, fordi gamepass-scriptet anvender den på hver ny karakter.
Almindelige fejl og løsninger
Åbn Output-vinduet (menuen Window, derefter Output), før du trykker på Play. De fleste problemer med disse scripts skriver en fejl eller en advarsel der med scriptets navn og linjenummer.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
MovementClient eller MovementCheck venter på et modul, der ikke findes under præcis det navn. Det skal være et ModuleScript med navnet MovementConfig direkte inde i ReplicatedStorage. Guiden til script-fejl gennemgår denne advarsel i detaljer.
Shift gør ingenting
Tjek, at ShiftToSprint eller MovementClient er et LocalScript og ikke et Script, og at det ligger i StarterPlayerScripts. Med MovementClient skal karakteren også gå og have mindst 20 stamina for at starte en sprint, så hold Shift nede, mens du bevæger dig. Hvis Shift Lock skifter i stedet for sprint, så se spørgsmålet om Shift Lock nedenfor.
Sprinten stopper efter nogle sekunder
Det er staminaen, der løber tør: 100 stamina med 20 i sekundet rækker til 5 sekunder. Hæv MAX_STAMINA, eller sænk DRAIN_PER_SECOND i MovementConfig.
Dashen gør ingenting
Dashen kræver 25 stamina, venter 1 sekund efter den forrige og gør ingenting, mens du sidder. Hvis det ikke er det, har din karakters rodpart måske ingen Attachment med navnet RootAttachment, det sker med nogle egne karakterer: tilføj den til HumanoidRootPart i din StarterCharacter.
Dobbelthoppet virker ikke
DoubleJump skal være et LocalScript i StarterCharacterScripts, ikke i StarterPlayerScripts, fordi det læser script.Parent som karakteren. Tryk på hop en gang til, efter at du har forladt jorden: en holdt knap tæller ikke som et nyt tryk, og at gå ud over en kant giver intet hop i luften.
Der er ingen Sprint- eller Dash-knap på telefonen
ContextActionService tilføjer kun sine knapper på touchenheder, så på en PC uden touchskærm ses de aldrig. Test med en telefon i Device Simulator i Studio (det er en beta: slå New Device Simulator til under File, Beta Features, og genstart Studio). BindAction kan højst oprette 7 touchknapper, så tæl, hvor mange andre scripts i spillet laver.
MovementCheck klager over ærlige spillere
De almindelige årsager: en teleport fra et andet server-script, et transportbånd eller et køretøj, eller lag. Sæt attributten MovementCheckSkip efter dine teleporter (se Respawns og teleporter), og hæv SPEED_ALLOWANCE, hvis tjekket stadig udløses i almindeligt spil.
Hastighedsforøgelsen forsvinder efter sprint
Et andet script ændrede WalkSpeed under sprinten, og da sprinten sluttede, satte den hastigheden tilbage til den, den så ved starten. Giv forøgelser, når karakteren spawner, som gamepass-guiden gør, så en respawn sætter den rigtige hastighed igen.
Lav det med RoCode
Hvis du ikke har lyst til at sætte alt det her op i hånden, kan RoCode bygge det i det place, du har åbent. RoCode er en uafhængig AI-agent til Roblox Studio, ikke fra Roblox: du beskriver ændringen i webchatten, og dens Studio-plugin opretter scripts i din Explorer, så du ikke behøver at indsætte kode.
Tilføj sprint med Shift og en stamina-bjælke: ganghastighed plus 10, mens Shift holdes nede, 100 stamina, forbrug 20 i sekundet, genopfyldning 15 i sekundet efter et sekunds hvile, en Sprint-knap på telefoner, dash på Q og dobbelthop.
- Kan først gennemse dit place med Search Scripts og Read Script for at finde andre scripts, der ændrer WalkSpeed (for eksempel en gamepass-fordel), så sprinten lægges oven i dem
- Skriver ModuleScript, LocalScripts og tjekket på serveren med Create Script
- Den er instrueret i at tjekke kompileringen af hvert script, den skriver, med Check Script, som kompilerer det i Studio uden at køre det
- Sætter et fortrydelsespunkt før og efter hver pakke ændringer, så Ctrl+Z ruller én pakke tilbage ad gangen
RoCode kan ikke lave en løbeanimation: lav den i Animation Editor, og indsæt dens ID. Med plugin 3.9.11 eller nyere kan RoCode køre en playtest af dit spil i Studio og styre en testfigur for at tjekke, at alt virker, og med plugin 3.9.15 eller nyere kan testfiguren trykke på taster, for eksempel holde Shift og tjekke, at WalkSpeed steg. Den bestemmer selv, hvornår der køres en playtest, op til 2 pr. build plus 1 for at tjekke sin rettelse, og tjekker kun det, den selv har besluttet at teste, så prøv selv sprint, dash og dobbelthop, og tjek knapperne på telefonen i Device Simulator i Studio. Bevægelse er ét system blandt mange i et spil; at lave et helt spil med RoCode foregår ét system pr. prompt, som her. Sådan forbinder RoCode til Studio.
Ofte stillede spørgsmål
Hvorfor virker sprint-scriptet ikke på telefonen?
En telefon har ingen Shift-tast. Bind sprint med ContextActionService:BindAction, og send true som tredje argument: det tilføjer en knap på skærmen på touchenheder, som både ShiftToSprint og MovementClient gør.
Skal sprint laves på serveren?
Nej. Hver enhed flytter sin egen karakter, så en WalkSpeed sat af serveren stopper ikke en snyder, der kan sætte sin egen, og den nye hastighed kommer først efter turen frem og tilbage, så sprinten starter med forsinkelse. Lav sprint på klienten, og tjek på serveren, hvor langt karaktererne faktisk flytter sig, som i trin 5. Robloxs beta server authority fungerer anderledes, og bevægelseskoden skal skrives om til den.
Hvorfor bliver karakteren ved med at sprinte, når jeg har sluppet Shift?
Scriptet missede slippet, som regel fordi det kun lytter efter trykket. ContextActionService sender End, når tasten slippes, og Cancel, når en anden binding overtager den; MovementClient stopper ved begge og også, når staminaen løber tør, eller karakteren holder op med at bevæge sig.
Hvordan tilføjer jeg en sprintanimation?
Indlæs en løbeanimation via Animator i karakterens Humanoid i det samme LocalScript, start den, når sprinten starter, og stop den, når den slutter. Giv den prioriteten Movement. Animationer, der startes på din egen karakter, kan ses af alle.
Hvorfor udløses dobbelthoppet af sig selv på telefonen?
En holdt hopknap på telefonen bliver ved med at bede om hop. Regn kun et hop som nyt, hvis forespørgslerne et øjeblik er holdt op, som scriptet DoubleJump gør.
Hvad er standardganghastigheden i Roblox?
16 studs i sekundet. Den kommer fra StarterPlayer.CharacterWalkSpeed, som sætter Humanoid.WalkSpeed for hver ny karakter. Sprinten fra denne guide lægger 10 til, så sprint går med 26.
Hvor hurtig skal en sprint være i Roblox?
De fleste spil lægger mellem en halv og en hel ganghastighed til: 16 bliver til noget mellem 24 og 32. En kort, langsom sprint passer til horror, og en lang, hurtig til store kort. Presets efter spiltype giver ganghastighed, sprintbonus og stamina-tal for hver.
Hvordan laver jeg sprint med stamina?
Gem et stamina-tal på spillerens enhed, brug af det hvert frame under sprint, og fyld det op efter en kort hvile, begge gange med hensyn til frametiden, og stop sprinten, når det når 0. MovementClient fra trin 3 gør det med en bjælke på skærmen; tallene ligger i MovementConfig.
Hvordan sprinter man med controller i Roblox?
Bind gamepaddens ButtonL3 (tryk på venstre stick) med ContextActionService sammen med Left Shift, som begge scripts her gør. ShiftToSprint gør L3 til en kontakt, fordi det er trættende at holde sticken trykket ind og samtidig styre med den.
Konflikter sprint med Shift med Shift Lock?
Det kan den. Spillere, der har slået Shift Lock til i Roblox-indstillingerne, skifter den med Shift-tasten, så én tast gør to ting. I Robloxs dokumentation står der, at Shift Lock-API'erne udfases. Hvis konflikten generer dine spillere, så slå StarterPlayer.EnableMouseLockOption fra, eller bind sprint i MovementClient til en anden tast, for eksempel Left Ctrl.
Kilder og videre læsning
- Roblox Creator Docs: ContextActionService (på engelsk). BindAction, touchknapper, grænsen på 7 knapper og hvorfor den i de fleste tilfælde er bedre end InputBegan
- Roblox Creator Docs: Humanoid (på engelsk). WalkSpeed og noten om sikkerhed, MoveDirection, StateChanged og ChangeState med et eksempel på dobbelthop
- Roblox Creator Docs: LinearVelocity (på engelsk). Plane-tilstand, tangentakser og MaxForce
- Roblox Creator Docs: Mover constraints (på engelsk). skift fra den forældede BodyVelocity til LinearVelocity
- Roblox Creator Docs: UserInputService (på engelsk). JumpRequest, og hvorfor den har brug for debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (på engelsk). hvad klienten styrer, afstandstjek, utætte spande og undtagelser for teleporter
- Roblox Creator Docs: Server authority model (på engelsk). modellen med bevægelse på serveren, BindToSimulation og de Workspace-indstillinger, den kræver
- Roblox Creator Docs: Input Action System (på engelsk). eksemplet 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
Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.