Pe scurt
Pune un singur LocalScript în StarterPlayerScripts, care leagă acțiunea Sprint prin ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Cât timp Shift e apăsat, adună 10 la Humanoid.WalkSpeed (16 devine 26), iar la eliberare readu valoarea de dinainte. Argumentul true adaugă un buton Sprint pe ecranele tactile, iar în scriptul din acest ghid acel buton și L3 pe gamepad pornesc și opresc alergarea, în loc să meargă prin ținere.
- Adună la WalkSpeed-ul curent, nu seta 26, ca bonusul de viteză dintr-un game pass să rămână.
- Sprintul rulează pe dispozitivul jucătorului. Serverul nu poate impune WalkSpeed; poate doar să măsoare cât de departe se mișcă personajele și să semnaleze o viteză pe care alergarea nu o explică.
- Bara de stamina, dash-ul și saltul dublu pe aceeași idee le adaugă Pașii de la 2 la 4. Cât de repede și cât timp să alergi îți spun presetările după tipul de joc, cu numere pentru horror, luptă și lume deschisă.
Pe această pagină
Cum funcționează sprintul în Roblox
Dispozitivul fiecărui jucător își mișcă propriul personaj. Tastatura, controllerul sau ecranul tactil decid încotro merge personajul, iar Roblox transmite rezultatul serverului și tuturor celorlalți. De aceea sprintul este un LocalScript care ridică Humanoid.WalkSpeed cât timp tasta e apăsată, și asta e tot ce face Pasul 1. Restul ghidului este ce îi trebuie unui joc mare în jurul lui: bara de stamina, dash-ul, saltul dublu și verificarea pe server împotriva trișorilor.
| Element | Unde se află | Ce face |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Pasul 1 de unul singur: sprint pe tastatură, telefon și gamepad, fără stamina. Când adaugi stamina și dash, îl înlocuiește MovementClient. |
ModuleScript MovementConfig | ReplicatedStorage | Numerele: bonusul de sprint, stamina și dash-ul. Le citesc și LocalScript-ul, și verificarea de pe server. |
LocalScript MovementClient | StarterPlayerScripts | Leagă Sprint și Dash de o tastă, un buton de gamepad și un buton tactil, rulează bucla de stamina, desenează bara și face dash-ul. |
LocalScript DoubleJump | StarterCharacterScripts | Dă un salt în plus în aer. O copie nouă pornește în fiecare personaj nou. |
Script MovementCheck | ServerScriptService | Măsoară cât de departe se mișcă de fapt fiecare personaj și scrie un avertisment în Output când cineva se mișcă mult timp mai repede decât permit sprintul și dash-ul. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Dacă diferența dintre Script și LocalScript e nouă pentru tine, Script, LocalScript și ModuleScript explică unde rulează fiecare tip și de ce.
Pasul 1: sprint cu Shift într-un singur LocalScript
Dacă vrei doar o alergare mai rapidă cât timp ții apăsat Shift, ajunge doar acest script. În plus, dă telefoanelor un buton Sprint pe ecran, iar pe gamepad te lasă să alergi din stick-ul stâng.
- În Explorer extinde StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts, apasă butonul + și inserează un LocalScript numit
ShiftToSprint. - Înlocuiește-i conținutul cu codul de mai jos și apasă Play.
-- LocalScript în StarterPlayer > StarterPlayerScripts, numit ShiftToSprint.
-- Ține apăsat Left Shift ca să alergi. Pe gamepad apasă stick-ul stâng (L3) ca să
-- pornești sau să oprești alergarea. Pe telefon apasă butonul Sprint ca s-o pornești sau s-o oprești.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Setări
local SPRINT_BONUS = 10 -- se adună la WalkSpeed în timpul alergării (16 devine 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: butonul trebuie ținut apăsat
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- WalkSpeed la care trebuie să revenim
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
-- Reținem viteza curentă și adunăm la ea, ca un bonus de viteză din alt script să rămână
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
-- Ținere: alergi cât timp tasta sau butonul e apăsat
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
-- Comutare: fiecare apăsare pornește sau oprește alergarea
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Un singur apel leagă tasta, butonul de gamepad și, pe ecranele tactile, un buton pe ecran
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- Un personaj nou începe mergând: Humanoid-ul lui are deja WalkSpeed-ul obișnuit
player.CharacterAdded:Connect(function()
sprinting = false
end)
Schimbă SPRINT_BONUS ca sprintul să fie mai rapid sau mai lent. Setează TOGGLE_ON_TOUCH_AND_GAMEPAD la false ca butonul de pe telefon și L3 să meargă ca Shift: sprint doar cât timp e apăsat.
BindAction leagă o singură acțiune de Left Shift și de butonul L3 de pe gamepad, iar al treilea argument, true, adaugă un buton pe ecranele tactile; SetTitle scrie pe el "Sprint". Handlerul primește și inputul propriu-zis, așa că deosebește o apăsare pe tastatură de gamepad sau de butonul tactil. Când pornește sprintul, scriptul reține WalkSpeed-ul curent și adună SPRINT_BONUS; când se termină, readuce valoarea reținută. Viteza setată de alt script, de exemplu perk-ul Speed din ghidul de game pass-uri, rămâne. Un personaj nou începe cu WalkSpeed-ul obișnuit, așa că handlerul CharacterAdded doar resetează flag-ul.
Ținere sau comutare?
| Dispozitiv și input | Funcționează prin | De ce |
|---|---|---|
| Tastatură: Left Shift | Ținere | E ușor să ții tasta în timp ce te miști, iar eliberarea oprește imediat sprintul. |
| Gamepad: apăsarea stick-ului stâng (L3) | Comutare | E obositor să ții stick-ul apăsat și în același timp să conduci cu el. |
| Telefon sau tabletă: butonul Sprint de pe ecran | Comutare | Degetul mare care ține butonul nu poate apăsa în același timp Jump. |
Ca să testezi, apasă Play și ține Shift în timp ce mergi: viteza crește de la 16 la 26 studs pe secundă, iar dacă eliberezi, încetinești. Pentru telefon alege un telefon în Device Simulator din Studio, apasă Play și apasă Sprint o dată ca să pornești și încă o dată ca să te oprești. Pentru gamepad deschide Controller Emulator în timpul playtestului și apasă L3. Lista completă de verificări pe dispozitive e în Pasul 6.
Pașii 2 și 3 înlocuiesc acest script cu altul, cu bară de stamina și dash. Pașii 4 și 5 adaugă saltul dublu și verificarea pe server și merg cu oricare dintre cele două scripturi.
Pasul 2: numerele de stamina și dash într-un singur modul
Pentru un sprint care se termină, Pașii 2 și 3 înlocuiesc ShiftToSprint cu un LocalScript mai mare, cu bară de stamina și dash. Mai întâi șterge ShiftToSprint: ambele scripturi leagă acțiunea Sprint.
Toate numerele stau într-un singur ModuleScript, așa că senzația mișcării se reglează într-un singur loc. MovementClient le citește pe dispozitivul fiecărui jucător, iar MovementCheck citește același modul pe server, ca să știe cât trebuie să fie viteza de sprint și de dash.
- În Explorer treci cu mouse-ul peste ReplicatedStorage, apasă butonul + și inserează un ModuleScript.
- Redenumește-l în
MovementConfigși înlocuiește-i conținutul cu codul de mai jos.
-- Un singur set de numere pentru LocalScript-ul de mișcare și verificarea vitezei pe server.
local MovementConfig = {
SPRINT_BONUS = 10, -- se adună la WalkSpeed-ul curent: 16 (valoarea implicită Roblox) devine 26
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 secunde de alergare cu bara plină
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- secunde după sfârșitul alergării până când stamina începe să se refacă
MIN_TO_START = 20, -- stamina necesară ca să pornești alergarea, ca bara goală să nu clipească
DASH_SPEED = 60, -- studs pe secundă în timpul dash-ului
DASH_SECONDS = 0.2, -- așa dash-ul parcurge în jur de 12 studs
DASH_COST = 25, -- stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Setare | Valoare | Efect |
|---|---|---|
SPRINT_BONUS | 10 | Se adună la WalkSpeed în timpul sprintului. WalkSpeed în Roblox este implicit 16, așa că sprintul merge cu 26 studs pe secundă. |
MAX_STAMINA | 100 | Bara plină. |
DRAIN_PER_SECOND | 20 | O bară plină ajunge pentru 5 secunde de sprint. |
REGEN_PER_SECOND | 15 | O bară goală se umple în aproximativ 6.7 secunde. |
REGEN_DELAY | 1 | Secunde de odihnă până începe refacerea. |
MIN_TO_START | 20 | Stamina necesară ca să pornești sprintul. |
DASH_SPEED | 60 | Studs pe secundă în timpul dash-ului. |
DASH_SECONDS | 0.2 | Cât durează dash-ul: în jur de 12 studs la 60 studs pe secundă. |
DASH_COST | 25 | Stamina pentru fiecare dash. |
DASH_COOLDOWN | 1 | Secunde între dash-uri. |
Fiecare parte rulează propria copie a modulului (un modul se execută o singură dată pe fiecare parte), așa că un jucător care schimbă aceste numere pe dispozitivul lui își schimbă doar copia lui. Dar aici asta nu protejează nimic: dispozitivul lui oricum îi mișcă personajul, așa că își poate da stamina infinită, orice ar fi în modul. Verificarea pe server din Pasul 5 e construită ținând cont de asta.
Pasul 3: sprint cu stamina și dash
Acest LocalScript face ce simt jucătorii. Leagă Sprint și Dash, desenează bara de stamina, rulează în fiecare cadru bucla de stamina și face dash-ul.
- În Explorer extinde StarterPlayer, treci cu mouse-ul peste StarterPlayerScripts și inserează un LocalScript numit
MovementClient. - Înlocuiește-i conținutul cu codul de mai jos.
-- Ține apăsat Shift (sau L3, sau butonul Sprint pe telefon) ca să alergi cât timp ai stamina.
-- Apasă Q (sau B, sau butonul Dash) ca să faci un dash în direcția mișcării.
local ContextActionService = game:GetService("ContextActionService")
local Debris = game:GetService("Debris")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
type Config = {
SPRINT_BONUS: number,
MAX_STAMINA: number,
DRAIN_PER_SECOND: number,
REGEN_PER_SECOND: number,
REGEN_DELAY: number,
MIN_TO_START: number,
DASH_SPEED: number,
DASH_SECONDS: number,
DASH_COST: number,
DASH_COOLDOWN: number,
}
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config
local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- WalkSpeed la care revenim când se termină alergarea
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Bara de stamina: un cadru cu umplere, a cărui lățime este stamina rămasă
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
-- Alergare: aici doar un flag; bucla Heartbeat de mai jos decide în fiecare cadru dacă alergi
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Îl schimbă doar apăsarea și eliberarea: un deget care alunecă pe butonul tactil trimite 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()
-- Fără dash când stai jos: un personaj așezat e sudat de scaun, așa că ar împinge tot vehiculul
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 -- punem refacerea pe pauză, cum face și alergarea
-- Dash în direcția în care se mișcă jucătorul sau în care privește dacă stă pe loc
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 în modul Plane ține viteza orizontală și nu încurcă gravitația
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
-- Fiecare apel leagă tasta, butonul de gamepad și, pe dispozitivele tactile, un buton pe ecran
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")
-- În fiecare cadru: consumăm stamina când alergi și te miști, o refacem după o scurtă pauză
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
-- Schimbăm WalkSpeed doar la începutul și la sfârșitul alergării, ca viteza setată
-- de alt script (de exemplu un pass de viteză) să rămână, iar alergarea să se adune la ea
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)
-- Un personaj nou începe cu stamina plină și nimic apăsat
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- un Humanoid nou începe cu WalkSpeed-ul obișnuit
end)
Bara de stamina se creează în cod cu ResetOnSpawn egal cu false, așa că rămâne pe ecran după respawn, iar handlerul CharacterAdded de jos o umple din nou pentru fiecare personaj nou. Liniile type Config descriu ce returnează modulul, ca verificarea strictă a tipurilor să prindă o greșeală de tipar în numele unei setări; în timpul jocului nu schimbă nimic.
Tastatură, gamepad și buton pe telefon dintr-un singur apel
ContextActionService:BindAction primește numele acțiunii, funcția handler, dacă să creeze un buton tactil, apoi inputurile. Dacă dai true ca al treilea argument, ContextActionService adaugă un buton pe ecran pe dispozitivele tactile, într-un ScreenGui numit ContextActionGui din PlayerGui-ul jucătorului. SetTitle scrie pe aceste butoane "Sprint" și "Dash". BindAction poate crea cel mult 7 butoane tactile, așa că urmărește numărul lor dacă le folosesc și alte scripturi din joc.
Handlerul primește starea inputului: Begin la apăsare și End la eliberare. onSprint doar reține dacă Sprint e apăsat. Socotește eliberare și Cancel, pe care ContextActionService îl trimite când inputul e preluat de altă legătură, și ignoră Change, pe care îl poate trimite un deget care se mișcă pe butonul tactil. Ambii handleri returnează Pass, așa că următoarea legătură pe aceeași tastă primește și ea inputul.
Referința Roblox pentru ContextActionService îl recomandă în locul lui UserInputService.InputBegan în majoritatea cazurilor. Exemplul ei: claxonul unei mașini pe H, care nu trebuie să claxoneze cât timp jucătorul scrie în chat. Legătura se declanșează doar cât timp e ultima pentru acel input, așa că, atunci când chatul ia tastatura, nu trebuie să verifici nimic. Inputurile de gamepad: ButtonL3 (apăsarea stick-ului stâng, ținut în timpul mișcării) și ButtonB. În propriul exemplu de sprint al Roblox se folosește ButtonY, așa că schimbă KeyCode-ul din BindAction dacă îi vine mai bine jocului tău.
Bucla de stamina
RunService.Heartbeat se declanșează în fiecare cadru după pasul de fizică și transmite deltaTime, numărul de secunde de la cadrul trecut. Dacă înmulțești cu el viteza de consum și de refacere, o bară plină ajunge pentru 5 secunde, fie că jocul merge la 30, fie la 240 de cadre pe secundă.
În fiecare cadru bucla decide dacă personajul trebuie să alerge: Sprint e apăsat, personajul merge (Humanoid.MoveDirection este vectorul zero când stă pe loc) și mai există stamina. Ca să pornești sprintul îți trebuie cel puțin MIN_TO_START (20); ca să continui, ajunge orice peste 0. Fără această diferență, o bară goală care se umple puțin în fiecare cadru ar porni și ar opri sprintul în fiecare cadru. Refacerea începe la REGEN_DELAY (1 secundă) după ultimul sprint sau dash, așa că, după ce golește bara, jucătorul așteaptă aproximativ 2.3 secunde până poate alerga din nou.
WalkSpeed se schimbă doar în cadrul în care sprintul începe sau se termină. La pornire scriptul reține WalkSpeed-ul curent și adună SPRINT_BONUS; la final readuce valoarea reținută. Astfel, viteza setată de alt script rămâne: perk-ul Speed din ghidul de game pass-uri setează WalkSpeed 24, iar cu acest script posesorii lui aleargă cu 34. Un script care scrie WalkSpeed = 16 în fiecare cadru sau la fiecare eliberare ar anula pe nesimțite acest perk.
Dash-ul
Dash-ul împinge personajul în direcția în care se mișcă sau în care privește dacă stă pe loc, iar direcția e aplatizată ca să nu arate niciodată în sus sau în jos. Costă 25 de stamina, pune refacerea pe pauză la fel ca sprintul și are un cooldown de 1 secundă. Solul nu e verificat, așa că merge și în aer, ceea ce se potrivește bine cu saltul dublu. Cât timp personajul stă jos, dash-ul nu face nimic: un personaj așezat e sudat de scaun, iar într-un vehicul împingerea ar putea mișca tot vehiculul.
Împingerea este o constrângere LinearVelocity pe RootAttachment-ul part-ului rădăcină. În modul Plane cu axele X și Z ține o viteză orizontală de 60 studs pe secundă și nu atinge verticala, așa că gravitația funcționează, iar un dash de pe o margine cade normal. MaxForce este math.huge, așa că împingerea nu e limitată de nimic. Debris:AddItem distruge constrângerea după DASH_SECONDS, fără să oblige scriptul să aștepte, așa că dash-ul durează 0.2 secunde, în jur de 12 studs la această viteză.
Tutorialele vechi folosesc BodyVelocity, pe care Roblox l-a marcat ca învechit, cu indicația de a folosi LinearVelocity în locul lui. Trucul lui cu MaxForce zero pe o axă e înlocuit de modurile Line, Plane și Vector ale LinearVelocity. Pentru că dispozitivul jucătorului își simulează singur personajul, o constrângere creată de un LocalScript îl mișcă, iar ceilalți jucători văd dash-ul ca pe orice altă mișcare.
Propriul tutorial de UI al Roblox atașează constrângerea la humanoid.RootPart.RootAttachment exact la fel. Dacă jocul tău are un personaj propriu, al cărui part rădăcină nu are un Attachment numit RootAttachment, dash-ul nu face nimic: adaugă-l în HumanoidRootPart-ul StarterCharacter-ului tău.
Pasul 4: saltul dublu
Saltul dublu stă în propriul LocalScript în StarterCharacterScripts. Roblox pune o copie a scripturilor din acest container în fiecare personaj la spawn, iar aceste copii nu supraviețuiesc unui respawn, așa că fiecare viață începe cu un script proaspăt și nimic nu se transferă din cea de dinainte.
- În Explorer extinde StarterPlayer, treci cu mouse-ul peste StarterCharacterScripts și inserează un LocalScript numit
DoubleJump. - Înlocuiește-i conținutul cu codul de mai jos.
-- Dă un salt în plus în aer. Pornește din nou pentru fiecare personaj nou,
-- așa că după respawn nu se transferă nimic.
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 se declanșează de mai multe ori la o singură apăsare
local NEW_PRESS_GAP = 0.1 -- un buton de salt ținut apăsat continuă să trimită JumpRequest; o pauză atât de lungă înseamnă că a fost eliberat
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
-- Un salt de pe sol (nu unul dintre salturile noastre în aer) reface salturile în aer
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- JumpRequest se declanșează când jucătorul cere un salt, de exemplu cu Space sau cu butonul de salt pe telefon
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Doar o apăsare nouă sare din nou, ca un buton ținut apăsat să nu consume saltul în aer
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)
Setează EXTRA_JUMPS la 2 pentru un salt triplu.
Scriptul urmărește starea personajului prin Humanoid.StateChanged. O trecere în Jumping care nu vine din Freefall este un salt de pe sol, așa că dă un salt în aer, iar Landed îl ia înapoi. Dacă cobori de pe o margine, personajul ajunge în Freefall fără salt, așa că nu primește salt în aer. Dacă îl vrei și acolo, setează jumpsLeft și la trecerea în Freefall din orice stare în afară de Jumping.
UserInputService.JumpRequest se declanșează când jucătorul cere un salt, de exemplu cu Space sau cu butonul de salt de pe telefon. Referința Roblox avertizează că se declanșează de mai multe ori la o singură cerere de salt și recomandă un debounce, așa că scriptul ignoră cererile timp de 0.25 secunde după ultimul salt. Un buton de salt ținut apăsat poate și el să tot ceară salturi și ar consuma saltul în aer în clipa în care personajul se desprinde de sol, așa că o cerere contează ca apăsare nouă doar după 0.1 secunde fără cereri.
Saltul în aer propriu-zis este Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Referința Roblox spune că trebuie apelat dintr-un LocalScript pe dispozitivul care are network ownership asupra personajului, iar implicit acesta e dispozitivul jucătorului, nu serverul. Exemplul de cod pentru ChangeState din referință este chiar un salt dublu.
Pasul 5: prindem speedhack-ul pe server
Tutorialele de sprint se opresc adesea la client. Un Script de pe server nu poate avea încredere în WalkSpeed-ul jucătorului, pentru că exploiterii îl schimbă pe dispozitivul lor, dar vede unde ajunge personajul lor. MovementCheck măsoară asta de două ori pe secundă și scrie un avertisment în Output când cineva se mișcă mult timp mai repede decât permit sprintul și dash-ul. Numerele de sprint și dash le citește din MovementConfig, așa că adaugă acest modul din Pasul 2, chiar dacă ai păstrat ShiftToSprint.
- Treci cu mouse-ul peste ServerScriptService și inserează un Script numit
MovementCheck. - Înlocuiește-i conținutul cu codul de mai jos.
-- Dispozitivele jucătorilor își mișcă propriile personaje, așa că un exploiter poate seta orice WalkSpeed.
-- Această verificare măsoară cât de departe se mișcă de fapt fiecare personaj și scrie în Output
-- când cineva se mișcă mult timp mai repede decât permit alergarea și dash-ul. Doar avertizează:
-- lagul, teleporturile și benzile transportoare pot arăta ca depășire de viteză, așa că reglați-o înainte să pedepsiți pe cineva.
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 -- secunde
-- Viteza de alergare plus o rezervă pentru lag. Măriți-o dacă vindeți bonusuri de viteză.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- rezervă pentru unul sau două dash-uri
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- cât de repede sunt iertate dash-urile trecute
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- part-ul rădăcină pe care s-a măsurat lastPosition
local excess: { [Player]: number } = {} -- studs peste toleranță, iertați treptat
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
-- Un respawn înseamnă un part rădăcină nou, iar un teleport pe server (start de rundă, checkpoint)
-- setează atributul de mai jos: începem să măsurăm din nou, nu marcăm saltul
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
-- Doar mișcarea orizontală: să cazi repede nu e trișat
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
Avertismentul apare în Output în Studio. Într-un joc live ajunge în logul de server din Developer Console, pe care îl poți citi ca proprietar al jocului: vezi outputul într-un joc live.
Ce măsoară
La fiecare jumătate de secundă scriptul citește poziția part-ului rădăcină al fiecărui personaj și măsoară cât s-a deplasat pe orizontală de la verificarea trecută. Înălțimea e ignorată, așa că căderile și salturile nu se pun niciodată la socoteală; sfatul Roblox despre verificarea mișcării propune aceeași proiecție pe planul XZ pentru jocurile în care se merge pe sol. Toleranța este viteza implicită de mers plus bonusul de sprint și încă un sfert pentru lag: 32.5 studs pe secundă. Distanța peste asta intră într-o „găleată găurită”, un acumulator despre care documentația Roblox spune că pentru mulți dezvoltatori se potrivește bine cu rafalele scurte. Găleata pierde 3 studs la fiecare verificare, iar scriptul avertizează când în ea sunt peste 24 studs, o rezervă pentru aproximativ două dash-uri.
| Trișor | Ce face MovementCheck |
|---|---|
| Setează WalkSpeed 100 | Avertizează după aproximativ o secundă de alergare |
| Setează WalkSpeed 50 | Avertizează după aproximativ 2.5 secunde de alergare |
| Face dash-uri la rând fără cooldown (60 studs pe secundă) | Avertizează după aproximativ 1.5 secunde |
| Se teleportează mai mult de 43 studs o dată | Avertizează la verificarea următoare |
| Aleargă cu până la 38 studs pe secundă, cam de o dată și jumătate mai repede decât sprintul | Nimic: sub 38.5 studs pe secundă găleata se golește la fel de repede cum se umple |
| Își schimbă MovementConfig-ul pentru stamina infinită | Nimic: sprintul cu 26 studs pe secundă e permis oricât de mult |
| Zboară, sare fără limită sau trece prin pereți | Nimic: verificarea ignoră înălțimea și nu se uită la coliziuni |
Așadar, verificarea prinde trișatul grosolan, la care jucătorul e vizibil mai rapid decât toți ceilalți, și le scapă pe cele atente. Aceasta e limita cinstită a unei verificări după distanță și motivul pentru care Roblox face ceva mai puternic (vezi server authority mai jos).
De ce doar avertizează
Documentația Roblox notează că verificările simple de viteză pot semnala jucători cinstiți cu o conexiune instabilă și se strică în jocurile cu vehicule sau altă mișcare complexă. Vârfurile de lag, benzile transportoare, vehiculele, exploziile care aruncă personajele și propriile tale teleporturi pot arăta ca depășire de viteză, așa că scriptul doar afișează un avertisment. Urmărește Output cât timp tu și testerii tăi jucați normal, mărește SPEED_ALLOWANCE dacă se împiedică de el jucători cinstiți și adaugă o pedeapsă, de exemplu readucerea jucătorului înapoi, doar când verificarea tace în jocul normal. Dacă în jocul tău exploziile aruncă personajele, sari peste jucătorii al căror Humanoid nu mai are viață.
Respawn-uri și teleporturi
Un respawn creează un part rădăcină nou, iar scriptul începe să măsoare din nou când îl vede, așa că o moarte departe de punctul de spawn nu se socotește niciodată depășire de viteză. Teleporturile pe care le fac propriile tale scripturi de server au nevoie de o excepție, cum spune documentația Roblox pentru orice joc cu teleporturi. După un teleport adaugă player:SetAttribute("MovementCheckSkip", true), iar verificarea următoare va începe să măsoare de la poziția nouă, în loc să marcheze saltul:
- În sistemul de runde, imediat după
character:PivotTo(...)înstartRound. - În scriptul de checkpointuri pentru obby, imediat după fiecare
character:PivotTo(...)care mută jucătorul la checkpointul lui.
Padurile și meniul din ghidul de teleporturi și padul Finish din ghidul primului joc îl setează deja după fiecare mutare.
Contează doar valoarea de pe server. Un atribut pe care jucătorul îl setează pe dispozitivul lui rămâne pe acel dispozitiv (vezi ce se replică și ce nu), așa că un trișor nu poate opri verificarea cu el.
Soluția de viitor: server authority
Documentația Roblox despre securitate numește modelul server authority, în beta la momentul scrierii, cel mai sigur mod de a opri exploiturile de mișcare. Sursa adevărului devine serverul, iar dispozitivele jucătorilor doar își raportează inputul, ceea ce, după documentație, nu lasă speedhack-urile să funcționeze, pentru că dispozitivului nu i se dă niciodată încrederea de a-și raporta propria poziție.
Trecerea este o rescriere, nu o reglare. În acest model mișcarea o calculează serverul, așa că WalkSpeed sau LinearVelocity setate doar de un LocalScript sunt anulate când sosește starea de pe server. Documentația Roblox spune că logica principală trebuie să ruleze în funcții RunService:BindToSimulation() dintr-un ModuleScript pe care îl rulează și clientul, și serverul. Modelul mai are nevoie și de câteva setări Workspace, inclusiv PlayerScriptsUseInputActionSystem, așa că și controalele tale se vor muta pe Input Action System. Păstrează versiunea din acest ghid până îți muți sprintul, stamina și dash-ul în această schemă. Până atunci, o verificare după distanță ca aceasta este exact ce descrie secțiunea Roblox despre verificarea mișcării.
Pasul 6: testează pe fiecare dispozitiv
- Apasă Play și ține Shift în timp ce mergi. Viteza crește de la 16 la 26 studs pe secundă, iar bara verde din partea de jos a ecranului scade. După aproximativ 5 secunde e goală și mergi din nou la pas.
- Eliberează Shift. După 1 secundă bara începe să se umple. Până nu se umple o cincime, Shift nu face nimic.
- Apasă Q în timp ce mergi: țâșnești puțin înainte, iar un sfert din bară dispare. Apasă imediat Q încă o dată și nu se întâmplă nimic până nu trece o secundă. Dacă dash-ul pare prea scurt sau prea lung, schimbă
DASH_SPEEDsauDASH_SECONDSîn MovementConfig. - Sari, apoi apasă saltul încă o dată în aer pentru al doilea salt. Aterizează și încearcă din nou: fiecare salt de pe sol îți dă înapoi saltul în aer.
- Ține Space apăsat tot saltul. Trebuie să iasă un singur salt, nu două, pentru că saltul în aer are nevoie de o apăsare nouă.
- Pornește Device Simulator în Studio (la momentul scrierii e beta: File, Beta Features, New Device Simulator, apoi repornește Studio) sau pornește vechiul Device Emulator din meniul Test. Alege un telefon și apasă Play. Apar butoanele Sprint și Dash. Ține Sprint în timp ce conduci, apoi ține butonul de salt tot saltul și verifică faptul că e un singur salt.
- Deschide Controller Emulator (Controller în fila Emulation sau Virtual controller în panoul Device Simulator). Ține L3 în timp ce te miști ca să alergi, apasă B pentru dash și A de două ori pentru saltul dublu.
- Resetează personajul din meniul jocului. Bara e din nou plină, în Output nu e niciun avertisment MovementCheck, iar dacă încă simulezi un telefon, butoanele Sprint și Dash sunt la locul lor.
- Acum joacă în rolul unui trișor. Apasă comutatorul Client/Server până când Explorer arată clientul, selectează Humanoid-ul personajului tău în Workspace și setează WalkSpeed la 60 în fereastra Properties. Mergi câteva secunde: în Output apare un avertisment de genul
MovementCheck: YourName moved 60 studs/s. Readu 16, apoi aleargă și fă dash-uri normal timp de un minut și verifică faptul că Output tace. - Dacă în place-ul tău
Workspace.PlayerScriptsUseInputActionSysteme pe Enabled, mai testează o dată saltul dublu: documentația Roblox nu spune dacăJumpRequestse comportă la fel cu ea.
Dacă nu se întâmplă absolut nimic, deschide fereastra Output din meniul Window din Studio și caută o eroare roșie de la MovementClient sau uită-te la erorile frecvente.
Cât de repede și cât timp: presetări după tipul de joc
Sprintul potrivit depinde de joc. O urmărire de horror vrea un sprint scurt și lent, care se termină în cel mai prost moment; o hartă mare deschisă vrea unul lung, ca jucătorii să nu se plictisească traversând-o. Aceste presetări folosesc aceleași scripturi și schimbă doar viteza de mers și MovementConfig. Sunt punctele noastre de plecare, calculate din setări, nu măsurate pe jucători.
| Tip de joc | CharacterWalkSpeed | SPRINT_BONUS (viteza de sprint) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Sprint complet | De la goală la plină | Distanța pe o bară |
|---|---|---|---|---|---|---|---|
| Acest ghid | 16 | 10 (26) | 20 | 15 | 5 s | 7.7 s | 130 studs |
| Urmărire în horror | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 studs |
| Battlegrounds și luptă | 16 | 12 (28) | 15 | 20 | 6.7 s | 6 s | în jur de 187 studs |
| Lume deschisă sau simulator | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 studs |
| Obby sau parkour | 16 | 8 (24) | fără stamina: folosește ShiftToSprint |
- Viteza de mers se setează în StarterPlayer. Selectează StarterPlayer și setează
CharacterWalkSpeed(implicit 16). Fiecare personaj nou pornește cu această viteză, sprintul adună la eaSPRINT_BONUS, iar MovementCheck o citește și el, așa că verificarea pe server urmează alegerea ta. - MovementCheck se adaptează. Permite viteza de mers plus bonusul de sprint și încă un sfert pentru lag: 25 studs pe secundă pentru presetarea de horror, 40 pentru lumea deschisă. Altceva nu trebuie schimbat.
- Într-un obby, sprintul schimbă traseul. Cu un sprint mai rapid se sar prăpăstii mai lungi. Construiește salturile, apoi testează-l pe fiecare la viteza de sprint, altfel sprintul face etapele prea ușoare. Ghidul de checkpointuri pentru obby se potrivește bine cu ShiftToSprint.
- În horror, reperul este ucigașul. Fă urmăritorul puțin mai rapid decât viteza de mers și puțin mai lent decât sprintul, ca scăparea să depindă de momentul în care se termină bara. Ghidul de joc horror explică restul buclei.
Ce e greșit la scripturile vechi de sprint
Tutorialele vechi de sprint, dash și salt dublu adesea încă funcționează, dar multe folosesc tehnici pe care Roblox le-a înlocuit între timp sau strică alte sisteme din jocul tău. Dacă repari un script copiat, compară-l cu această listă.
| Tehnică | Care e problema | Acest ghid |
|---|---|---|
BodyVelocity pentru dash | Învechit: Roblox spune să folosești LinearVelocity în locul lui | LinearVelocity în modul Plane |
Bucla pe RunService.RenderStepped | Pentru munca nouă l-a înlocuit PreRender. Logica de joc precum stamina își are locul pe Heartbeat, pe care Roblox îl descrie pentru sarcini periodice, cum e refacerea vieții | Heartbeat cu deltaTime |
Bucla de stamina pe wait() | wait() e învechit în favoarea lui task.wait() și e frânat, așa că poate aștepta mai mult decât i s-a cerut, iar un consum fix la fiecare wait consumă stamina neuniform | Consum și refacere în fiecare cadru ținând cont de deltaTime |
UserInputService.InputBegan fără verificarea chatului | Apăsarea lui Shift în timp ce scrii un mesaj în chat pornește sprintul | ContextActionService, care mai adaugă și butonul pe telefon |
WalkSpeed = 16 la eliberare sau în fiecare cadru | Suprascrie orice altă viteză, de exemplu perk-ul unui game pass | Schimbă WalkSpeed doar la începutul și la sfârșitul sprintului, adunând la valoarea curentă |
| Sprint printr-un RemoteEvent, ca WalkSpeed să-l seteze serverul | Exploiterii oricum își setează singuri WalkSpeed, iar sprintul pornește cu întârzierea drumului dus-întors | Sprint pe client plus verificarea distanței pe server |
Salt dublu la fiecare JumpRequest | JumpRequest se declanșează de mai multe ori la o singură cerere de salt, iar un buton ținut apăsat poate tot cere salturi | Pauză de 0.25 secunde și verificarea unei apăsări noi |
UserInputService.TouchEnabled ca verificare „e un telefon” | E true pe laptopurile cu ecran tactil | ContextActionService adaugă butoane pe ecran pe dispozitivele tactile fără o verificare proprie a dispozitivului |
Humanoid:LoadAnimation pentru animația de alergare | Învechit în favoarea lui Animator:LoadAnimation | Animația de alergare de mai jos folosește Animator |
Noua metodă de la Roblox: Input Action System
Pagina Roblox despre Input Action System ia sprintul personajului ca prim exemplu. În locul apelurilor BindAction, controalele se configurează în Studio: un InputAction numit CharacterSprint într-un input context din ReplicatedStorage, cu un InputBinding pentru Left Shift, unul pentru butonul Y de pe gamepad și unul legat de un buton pe ecran pe care îl desenezi în StarterGui. Apoi un script de client ascultă evenimentele acțiunii Pressed și Released, dublând WalkSpeed la apăsare și readucându-l la eliberare.
Merită să treci pe el dacă vrei să aranjezi controalele în Studio, nu în cod, un buton tactil propriu în locul butonului ContextActionService sau contexte care schimbă seturi întregi de controale, de exemplu pentru meniuri sau vehicule. Pagina recomandă și setarea Workspace.PlayerScriptsUseInputActionSystem pe Enabled, iar server authority o cere.
Bucla de stamina și dash-ul din acest ghid funcționează la fel doar cu Input Action System (fără server authority). Păstrează MovementConfig, bucla Heartbeat și dash(), șterge cele două apeluri BindAction și handlerii lor și conectează în locul lor acțiunile: Pressed al acțiunii de sprint setează sprintHeld la true, iar Released al ei la false, iar Pressed al acțiunii de dash apelează dash(). Continuă să cauți Humanoid-ul în fiecare cadru, cum face MovementClient, pentru că exemplul din documentație păstrează Humanoid-ul primului personaj, iar după respawn acesta nu mai există.
Roblox testează și Character Controller Library, o beta care se pornește în Beta Features și Avatar Settings în Studio. Pagina ei despre abilitățile proprii construiește ca exemplu un dash cu o fereastră activă de 0.2 secunde și un cooldown de 1 secundă, adică exact timingul dash-ului din acest ghid.
Cum îl extinzi: animație, cameră și pass pentru sprint
Animația de alergare
Fă o animație de alergare în Animation Editor, dă-i prioritatea Movement (Roblox o recomandă pentru animațiile de mers și alergare), public-o și copiază ID-ul asset-ului. În MovementClient creează un Animation cu acest AnimationId, încarc-o prin Animator:LoadAnimation, folosind Animator-ul din Humanoid-ul personajului, pornește trackul acolo unde începe sprintul și oprește-l acolo unde se termină. Încarc-o din nou pentru fiecare personaj nou.
Animațiile pe care dispozitivul tău le pornește pe personajul tău le văd toți, dacă folosești Animator-ul pus acolo de Roblox: trackurile încărcate pe un Animator creat de un LocalScript nu se replică. Humanoid:LoadAnimation, folosit de multe tutoriale vechi, e învechit.
Camera mai largă în timpul sprintului
Un unghi de vedere puțin mai larg face sprintul să pară mai rapid. În aceleași două locuri aplică un tween pe workspace.CurrentCamera.FieldOfView de la valoarea implicită 70 până la aproximativ 80 când începe sprintul și înapoi când se termină, de exemplu prin TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox limitează valoarea între 1 și 120 și avertizează că valorile foarte mici sau foarte mari pot dezorienta jucătorii. Dacă unghiul de vedere îl mai schimbă și alt script din joc, fă tween-ul înapoi la valoarea găsită, nu la 70.
Sprint rapid ca game pass
Ghidul de game pass-uri merge deja cu acest script: perk-ul lui Speed de pe server setează WalkSpeed 24 fiecărui personaj nou, MovementClient adună deasupra bonusul de sprint, iar 34 studs pe secundă rămân în limitele a ce permite MovementCheck.
Pentru un pass care accelerează sprintul în sine, adaugă un pass FastSprint în PassConfig.ids din acel ghid. Scriptul lui de server îi setează atunci jucătorului atributul OwnsPass_FastSprint imediat ce cumpărarea e confirmată. În MovementClient folosește un bonus mai mare decât Config.SPRINT_BONUS când player:GetAttribute("OwnsPass_FastSprint") == true. În MovementCheck dă acestor jucători o toleranță mai mare, citind același atribut pe server, unde jucătorul nu îl poate schimba, și verifică faptul că noua viteză maximă rămâne sub ce semnalează verificarea.
O limitare de care e bine să știi: dacă alt script schimbă WalkSpeed în mijlocul unui sprint, sfârșitul acelui sprint va readuce viteza de dinaintea lui. Următorul respawn va seta din nou viteza pass-ului, pentru că scriptul de game pass o aplică fiecărui personaj nou.
Erori frecvente și soluții
Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Majoritatea problemelor cu aceste scripturi afișează acolo o eroare sau un avertisment cu numele scriptului și numărul liniei.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
MovementClient sau MovementCheck așteaptă un modul care nu există cu exact acest nume. Trebuie să fie un ModuleScript numit MovementConfig direct în ReplicatedStorage. Ghidul de erori de script explică în detaliu acest avertisment.
Shift nu face nimic
Verifică faptul că ShiftToSprint sau MovementClient este un LocalScript, nu un Script, și că stă în StarterPlayerScripts. Cu MovementClient, ca sprintul să pornească, personajul trebuie și să meargă și să aibă cel puțin 20 de stamina, așa că ține Shift în timp ce te miști. Dacă în locul sprintului se comută Shift Lock, vezi întrebarea despre Shift Lock de mai jos.
Sprintul se oprește după câteva secunde
Se termină stamina: 100 de stamina cu 20 pe secundă ajung pentru 5 secunde. Mărește MAX_STAMINA sau micșorează DRAIN_PER_SECOND în MovementConfig.
Dash-ul nu face nimic
Dash-ul are nevoie de 25 de stamina, așteaptă 1 secundă după cel de dinainte și nu face nimic cât timp stai jos. Dacă nu e asta, part-ul rădăcină al personajului tău poate să nu aibă un Attachment numit RootAttachment, cum se întâmplă la unele personaje proprii: adaugă-l în HumanoidRootPart-ul StarterCharacter-ului tău.
Saltul dublu nu se declanșează
DoubleJump trebuie să fie un LocalScript în StarterCharacterScripts, nu în StarterPlayerScripts, pentru că citește script.Parent ca personaj. Apasă saltul a doua oară după ce te desprinzi de sol: un buton ținut apăsat nu contează ca apăsare nouă, iar coborârea de pe o margine nu dă salt în aer.
Pe telefon nu există butonul Sprint sau Dash
ContextActionService își adaugă butoanele doar pe dispozitivele tactile, așa că pe un PC fără ecran tactil nu se văd niciodată. Testează cu un telefon în Device Simulator din Studio (e beta: pornește New Device Simulator în File, Beta Features și repornește Studio). BindAction poate crea cel mult 7 butoane tactile, așa că numără câte fac alte scripturi din joc.
MovementCheck se plânge de jucători cinstiți
Cauzele obișnuite: un teleport din alt script de server, o bandă transportoare sau un vehicul, ori lagul. Setează atributul MovementCheckSkip după teleporturile tale (vezi Respawn-uri și teleporturi) și mărește SPEED_ALLOWANCE dacă verificarea încă se declanșează în jocul normal.
Bonusul de viteză dispare după sprint
Alt script a schimbat WalkSpeed în timpul sprintului, iar sprintul, la final, a readus viteza pe care a văzut-o la pornire. Dă bonusurile de viteză la spawn-ul personajului, cum face ghidul de game pass-uri, ca respawn-ul să seteze din nou viteza corectă.
Fă-l cu RoCode
Dacă nu ai chef să configurezi toate acestea de mână, RoCode le poate construi în place-ul pe care îl ai deschis. RoCode este un agent AI independent pentru Roblox Studio, nu de la Roblox: descrii schimbarea în chatul web, iar pluginul lui pentru Studio creează scripturile în Explorer-ul tău, așa că nu trebuie să lipești cod.
Adaugă sprint cu Shift cu bară de stamina: viteza de mers plus 10 cât timp e apăsat Shift, 100 de stamina, consum de 20 pe secundă, refacere de 15 pe secundă după o secundă de odihnă, buton Sprint pe telefoane, dash pe Q și salt dublu.
- Poate întâi să-ți parcurgă place-ul prin Search Scripts și Read Script, ca să găsească alte scripturi care schimbă WalkSpeed (de exemplu perk-ul unui game pass), iar sprintul să se adune la ele
- Scrie ModuleScript-ul, LocalScript-urile și verificarea de pe server prin Create Script
- Are instrucțiunea să verifice compilarea fiecărui script scris prin Check Script, care îl compilează în Studio fără să-l ruleze
- Pune un punct de undo înainte și după fiecare pachet de schimbări, așa că Ctrl+Z anulează câte un pachet
RoCode nu știe să facă animația de alergare: creeaz-o în Animation Editor și lipește-i ID-ul. Cu pluginul 3.9.11 sau mai nou, RoCode poate porni un playtest al jocului tău în Studio și poate controla un personaj de test ca să verifice că totul merge, iar cu pluginul 3.9.15 sau mai nou personajul de test poate apăsa taste, de exemplu să țină Shift și să verifice că WalkSpeed a crescut. Decide singur când să pornească playtestul, până la 2 pe build plus 1 ca să-și verifice reparația, și verifică doar ce a hotărât singur să testeze, așa că sprintul, dash-ul și saltul dublu încearcă-le tu, iar butoanele de pe telefon verifică-le în Device Simulator din Studio. Mișcarea este un sistem dintre multe dintr-un joc; crearea unui joc întreg cu RoCode merge câte un sistem pe prompt, ca aici. Cum se conectează RoCode la Studio.
Întrebări frecvente
De ce scriptul de sprint nu merge pe telefon?
Telefonul nu are tasta Shift. Leagă sprintul prin ContextActionService:BindAction și dă true ca al treilea argument: asta adaugă un buton pe ecran pe dispozitivele tactile, cum fac și ShiftToSprint, și MovementClient.
Trebuie să fac sprintul pe server?
Nu. Fiecare dispozitiv își mișcă propriul personaj, așa că un WalkSpeed setat de server nu oprește un trișor care îl poate seta pe al lui, iar viteza nouă sosește doar după drumul dus-întors, așa că sprintul pornește cu întârziere. Fă sprintul pe client, iar pe server verifică cât de departe se mișcă de fapt personajele, ca în Pasul 5. Beta server authority de la Roblox funcționează altfel, iar codul de mișcare va trebui rescris pentru ea.
De ce personajul continuă să alerge după ce am eliberat Shift?
Scriptul a ratat eliberarea, de obicei pentru că ascultă doar apăsarea. ContextActionService trimite End când tasta e eliberată și Cancel când o preia altă legătură; MovementClient se oprește la amândouă, și de asemenea când se termină stamina sau personajul nu se mai mișcă.
Cum adaug o animație de alergare?
Încarcă animația de alergare prin Animator-ul din Humanoid-ul personajului în același LocalScript, pornește-o când începe sprintul și oprește-o când se termină. Dă-i prioritatea Movement. Animațiile pornite pe propriul tău personaj le văd toți.
De ce saltul dublu se declanșează singur pe telefon?
Un buton de salt ținut apăsat pe telefon continuă să ceară salturi. Socotește un salt nou doar dacă cererile s-au oprit pentru o clipă, cum face scriptul DoubleJump.
Care e viteza de mers implicită în Roblox?
16 studs pe secundă. Vine din StarterPlayer.CharacterWalkSpeed, care setează Humanoid.WalkSpeed al fiecărui personaj nou. Sprintul din acest ghid adună 10, așa că sprintul merge cu 26.
Cât de rapid trebuie să fie sprintul în Roblox?
Majoritatea jocurilor adună între jumătate și o viteză de mers întreagă: 16 devine ceva între 24 și 32. Un sprint scurt și lent se potrivește la horror, iar unul lung și rapid la hărțile mari. Presetările după tipul de joc dau pentru fiecare viteza de mers, bonusul de sprint și numerele de stamina.
Cum fac un sprint cu stamina?
Păstrează un număr de stamina pe dispozitivul jucătorului, consumă-l în fiecare cadru în timpul sprintului și refă-l după o scurtă odihnă, de ambele dăți ținând cont de timpul cadrului, și oprește sprintul când a ajuns la 0. MovementClient din Pasul 3 face asta cu o bară pe ecran; numerele stau în MovementConfig.
Cum alergi cu un controller în Roblox?
Leagă ButtonL3 al gamepadului (apăsarea stick-ului stâng) prin ContextActionService împreună cu Left Shift, cum fac ambele scripturi de aici. ShiftToSprint face din L3 un comutator, pentru că e obositor să ții stick-ul apăsat și în același timp să conduci cu el.
Intră în conflict sprintul cu Shift cu Shift Lock?
Poate. Jucătorii care au pornit Shift Lock în setările Roblox îl comută cu tasta Shift, așa că o singură tastă face două lucruri. Documentația Roblox spune că API-urile Shift Lock sunt scoase din uz. Dacă conflictul îi încurcă pe jucătorii tăi, oprește StarterPlayer.EnableMouseLockOption sau leagă sprintul din MovementClient de altă tastă, de exemplu Left Ctrl.
Surse și lecturi suplimentare
- Roblox Creator Docs: ContextActionService (în engleză). BindAction, butoanele tactile, limita de 7 butoane și de ce în majoritatea cazurilor e mai bun decât InputBegan
- Roblox Creator Docs: Humanoid (în engleză). WalkSpeed și nota despre securitate, MoveDirection, StateChanged și ChangeState cu exemplul de salt dublu
- Roblox Creator Docs: LinearVelocity (în engleză). modul Plane, axele tangente și MaxForce
- Roblox Creator Docs: Mover constraints (în engleză). trecerea de la BodyVelocity învechit la LinearVelocity
- Roblox Creator Docs: UserInputService (în engleză). JumpRequest și de ce are nevoie de debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (în engleză). ce controlează clientul, verificările de distanță, găleți găurite și excepții pentru teleporturi
- Roblox Creator Docs: Server authority model (în engleză). modelul cu mișcarea pe server, BindToSimulation și setările Workspace de care are nevoie
- Roblox Creator Docs: Input Action System (în engleză). exemplul Character Sprint cu InputAction și InputBinding
- Roblox Creator Docs: Custom abilities (în engleză). abilitatea de dash din Character Controller Library
- Roblox Creator Docs: Studio testing modes (în engleză). Device Simulator și Controller Emulator
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.