In breve
Metti un solo LocalScript in StarterPlayerScripts che collega l'azione Sprint con ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Finché Shift è premuto, aggiungi 10 a Humanoid.WalkSpeed (16 diventa 26), e al rilascio torna al valore precedente. L'argomento true aggiunge un pulsante Sprint sui touch screen, e nello script di questa guida quel pulsante e L3 sul gamepad attivano e disattivano la corsa, invece di funzionare tenendoli premuti.
- Aggiungi al WalkSpeed attuale, non impostare 26, così l'accelerazione di un game pass resta.
- La corsa funziona sul dispositivo del giocatore. Il server non può imporre il WalkSpeed; può solo misurare quanto si spostano i personaggi e segnalare una velocità che la corsa non spiega.
- Barra della stamina, scatto e doppio salto sulla stessa idea li aggiungono i passi da 2 a 4. Quanto veloce e per quanto correre te lo suggeriscono i preset per tipo di gioco, con numeri per horror, combattimento e open world.
In questa pagina
Come funziona la corsa su Roblox
Il dispositivo di ogni giocatore muove il suo personaggio. Tastiera, controller o touch screen decidono dove va il personaggio, e Roblox passa il risultato al server e a tutti gli altri. Per questo la corsa è un LocalScript che alza Humanoid.WalkSpeed finché il tasto è premuto, ed è tutto ciò che fa il passo 1. Il resto della guida è ciò che serve a un gioco più grande attorno a questo: barra della stamina, scatto, doppio salto e un controllo sul server per chi bara.
| Elemento | Dove si trova | Cosa fa |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Il passo 1 da solo: corsa su tastiera, telefono e gamepad, senza stamina. Quando aggiungi stamina e scatto, lo sostituisce MovementClient. |
ModuleScript MovementConfig | ReplicatedStorage | I numeri: bonus di corsa, stamina e scatto. Li leggono sia il LocalScript sia il controllo sul server. |
LocalScript MovementClient | StarterPlayerScripts | Collega Sprint e Dash a un tasto, a un pulsante del gamepad e a un pulsante touch, fa girare il ciclo della stamina, disegna la barra ed esegue lo scatto. |
LocalScript DoubleJump | StarterCharacterScripts | Dà un salto in più in aria. Una nuova copia parte in ogni nuovo personaggio. |
Script MovementCheck | ServerScriptService | Misura quanto si sposta davvero ogni personaggio e scrive un avviso nell'Output quando qualcuno si muove a lungo più veloce di quanto permettano corsa e scatto. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Se la differenza tra Script e LocalScript ti è nuova, Script, LocalScript e ModuleScript (in inglese) spiega dove gira ciascun tipo e perché.
Passo 1: correre con Shift in un solo LocalScript
Se ti serve solo una corsa più veloce finché Shift è premuto, basta questo script. In più dà ai telefoni un pulsante Sprint sullo schermo e sul gamepad permette di correre con la levetta sinistra.
- Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts, clicca sul pulsante + e inserisci un LocalScript chiamato
ShiftToSprint. - Sostituisci il suo contenuto con il codice qui sotto e premi Play.
-- LocalScript in StarterPlayer > StarterPlayerScripts chiamato ShiftToSprint.
-- Tieni premuto Left Shift per correre. Sul gamepad premi la levetta sinistra (L3) per
-- attivare o disattivare la corsa. Sul telefono tocca il pulsante Sprint per attivarla o disattivarla.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Impostazioni
local SPRINT_BONUS = 10 -- si aggiunge al WalkSpeed durante la corsa (16 diventa 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: il pulsante va tenuto premuto
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- il WalkSpeed a cui tornare
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
-- Ricordiamo la velocità attuale e aggiungiamo a quella, così un'accelerazione da un altro script resta
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
-- Tenere premuto: corsa finché il tasto o il pulsante è premuto
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
-- Attiva/disattiva: ogni pressione accende o spegne la corsa
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Una sola chiamata collega il tasto, il pulsante del gamepad e, sui touch screen, il pulsante sullo schermo
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- Un nuovo personaggio parte camminando: il suo Humanoid ha già il WalkSpeed normale
player.CharacterAdded:Connect(function()
sprinting = false
end)
Cambia SPRINT_BONUS per rendere la corsa più veloce o più lenta. Imposta TOGGLE_ON_TOUCH_AND_GAMEPAD a false perché il pulsante sul telefono e L3 funzionino come Shift: corsa solo finché è premuto.
BindAction collega una sola azione a Left Shift e al pulsante L3 del gamepad, e il suo terzo argomento, true, aggiunge un pulsante sui touch screen; SetTitle ci scrive sopra "Sprint". Il gestore riceve anche l'input stesso, quindi distingue una pressione da tastiera da quella di un gamepad o di un pulsante touch. Quando la corsa inizia, lo script ricorda il WalkSpeed attuale e aggiunge SPRINT_BONUS; quando finisce, ripristina il valore ricordato. Una velocità impostata da un altro script, per esempio il vantaggio Speed della guida ai game pass (in inglese), resta. Un nuovo personaggio parte con il WalkSpeed normale, quindi il gestore CharacterAdded azzera solo il flag.
Tenere premuto o attiva/disattiva?
| Dispositivo e input | Funziona come | Perché |
|---|---|---|
| Tastiera: Left Shift | Tenere premuto | Tenere premuto il tasto mentre ti muovi è facile, e al rilascio la corsa si ferma subito. |
| Gamepad: pressione della levetta sinistra (L3) | Attiva/disattiva | Tenere la levetta premuta e intanto sterzare con essa è faticoso. |
| Telefono o tablet: pulsante Sprint sullo schermo | Attiva/disattiva | Il pollice che tiene il pulsante non può nello stesso momento premere Jump. |
Per provare, premi Play e tieni premuto Shift mentre cammini: la velocità sale da 16 a 26 stud al secondo, e se rilasci rallenti. Per il telefono scegli un telefono nel Device Simulator di Studio, premi Play e tocca Sprint una volta per iniziare e ancora per fermarti. Per il gamepad apri il Controller Emulator durante il playtest e premi L3. L'elenco completo delle prove per dispositivo è nel passo 6.
I passi 2 e 3 sostituiscono questo script con un altro, con barra della stamina e scatto. I passi 4 e 5 aggiungono il doppio salto e il controllo sul server e funzionano con uno qualsiasi dei due script.
Passo 2: i numeri di stamina e scatto in un solo modulo
Per una corsa che si esaurisce, i passi 2 e 3 sostituiscono ShiftToSprint con un LocalScript più grande, con barra della stamina e scatto. Prima elimina ShiftToSprint: entrambi gli script collegano l'azione Sprint.
Tutti i numeri stanno in un solo ModuleScript, così la sensazione del movimento si regola in un unico posto. MovementClient li legge sul dispositivo di ogni giocatore, e MovementCheck legge lo stesso modulo sul server per sapere quale deve essere la velocità di corsa e di scatto.
- Nell'Explorer passa il mouse su ReplicatedStorage, clicca sul pulsante + e inserisci un ModuleScript.
- Rinominalo in
MovementConfige sostituisci il contenuto con il codice qui sotto.
-- Un solo insieme di numeri per il LocalScript del movimento e il controllo della velocità sul server.
local MovementConfig = {
SPRINT_BONUS = 10, -- si aggiunge al WalkSpeed attuale: 16 (il valore predefinito di Roblox) diventa 26
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 secondi di corsa con la barra piena
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- secondi dopo la fine della corsa prima che la stamina inizi a recuperare
MIN_TO_START = 20, -- stamina necessaria per iniziare a correre, così la barra vuota non lampeggia
DASH_SPEED = 60, -- stud al secondo durante lo scatto
DASH_SECONDS = 0.2, -- così lo scatto percorre circa 12 stud
DASH_COST = 25, -- stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Impostazione | Valore | Effetto |
|---|---|---|
SPRINT_BONUS | 10 | Si aggiunge al WalkSpeed durante la corsa. Il WalkSpeed predefinito di Roblox è 16, quindi la corsa va a 26 stud al secondo. |
MAX_STAMINA | 100 | La barra piena. |
DRAIN_PER_SECOND | 20 | La barra piena basta per 5 secondi di corsa. |
REGEN_PER_SECOND | 15 | La barra vuota si riempie in circa 6.7 secondi. |
REGEN_DELAY | 1 | Secondi di riposo prima che inizi il recupero. |
MIN_TO_START | 20 | Stamina necessaria per iniziare a correre. |
DASH_SPEED | 60 | Stud al secondo durante lo scatto. |
DASH_SECONDS | 0.2 | Quanto dura lo scatto: circa 12 stud a 60 stud al secondo. |
DASH_COST | 25 | Stamina per ogni scatto. |
DASH_COOLDOWN | 1 | Secondi tra uno scatto e l'altro. |
Ogni lato esegue la propria copia del modulo (un modulo viene eseguito una volta per ogni lato (in inglese)), quindi un giocatore che cambia questi numeri sul suo dispositivo cambia solo la sua copia. Ma qui questo non protegge niente: il suo dispositivo muove già il suo personaggio, quindi può darsi stamina infinita qualunque cosa ci sia nel modulo. Il controllo sul server del passo 5 è costruito tenendo conto di questo.
Passo 3: corsa con stamina e scatto
Questo LocalScript fa ciò che sentono i giocatori. Collega Sprint e Dash, disegna la barra della stamina, fa girare ogni frame il ciclo della stamina ed esegue lo scatto.
- Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato
MovementClient. - Sostituisci il suo contenuto con il codice qui sotto.
-- Tieni premuto Shift (o L3, o il pulsante Sprint sul telefono) per correre finché c'è stamina.
-- Premi Q (o B, o il pulsante Dash) per fare uno scatto nella direzione del movimento.
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 -- il WalkSpeed a cui tornare quando la corsa finisce
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Barra della stamina: un riquadro con un riempimento la cui larghezza è la stamina rimasta
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
-- Corsa: qui c'è solo il flag; il ciclo Heartbeat qui sotto decide ogni frame se correre
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Lo cambiano solo pressione e rilascio: un dito che scorre sul pulsante touch invia 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()
-- Da seduti niente scatto: un personaggio seduto è saldato al sedile, quindi spingerebbe tutto il veicolo
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 -- mettiamo in pausa il recupero, come fa la corsa
-- Scatto verso dove il giocatore si muove, o verso dove guarda se è fermo
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 in modalità Plane mantiene la velocità orizzontale e non ostacola la gravità
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
-- Ogni chiamata collega un tasto, un pulsante del gamepad e, sui dispositivi touch, un pulsante sullo schermo
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")
-- Ogni frame: consumiamo stamina mentre si corre e ci si muove, la recuperiamo dopo un breve riposo
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
-- Cambiamo il WalkSpeed solo all'inizio e alla fine della corsa, così una velocità impostata
-- da un altro script (per esempio un pass velocità) resta, e la corsa si aggiunge a quella
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 nuovo personaggio parte con la stamina piena e niente premuto
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- un nuovo Humanoid parte con il WalkSpeed normale
end)
La barra della stamina viene creata nel codice con ResetOnSpawn a false, quindi resta sullo schermo dopo il respawn, e il gestore CharacterAdded in fondo la riempie di nuovo per ogni nuovo personaggio. Le righe type Config descrivono cosa restituisce il modulo, così il controllo rigoroso dei tipi trova un errore di battitura nel nome di un'impostazione; durante il gioco non cambiano nulla.
Tastiera, gamepad e pulsante sul telefono con una sola chiamata
ContextActionService:BindAction riceve il nome dell'azione, la funzione che la gestisce, se creare un pulsante touch, e poi gli input. Se passi true come terzo argomento, ContextActionService aggiunge un pulsante sullo schermo sui dispositivi touch, dentro una ScreenGui chiamata ContextActionGui nella PlayerGui del giocatore. SetTitle scrive "Sprint" e "Dash" su questi pulsanti. BindAction può creare al massimo 7 pulsanti touch, quindi tieni d'occhio il numero se li usano anche altri script del gioco.
Il gestore riceve lo stato dell'input: Begin alla pressione e End al rilascio. onSprint ricorda solo se Sprint è premuto. Considera rilascio anche Cancel, che ContextActionService invia quando l'input viene preso da un altro collegamento, e ignora Change, che può arrivare da un dito che si muove sul pulsante touch. Entrambi i gestori restituiscono Pass, quindi anche il collegamento successivo sullo stesso tasto riceve l'input.
Il riferimento di Roblox su ContextActionService lo consiglia al posto di UserInputService.InputBegan nella maggior parte dei casi. Il suo esempio: il clacson di un'auto sul tasto H, che non deve suonare mentre il giocatore scrive in chat. Un collegamento scatta solo finché è l'ultimo per quell'input, quindi quando la chat prende la tastiera non devi controllare nulla. Gli input del gamepad: ButtonL3 (la pressione della levetta sinistra, che si tiene durante il movimento) e ButtonB. L'esempio di corsa di Roblox usa ButtonY, quindi cambia il KeyCode in BindAction se nel tuo gioco è più comodo.
Il ciclo della stamina
RunService.Heartbeat scatta ogni frame dopo il passo della fisica e passa deltaTime, il numero di secondi dal frame precedente. Se moltiplichi per questo la velocità di consumo e di recupero, la barra piena dura 5 secondi sia che il gioco giri a 30 sia a 240 frame al secondo.
Ogni frame il ciclo decide se il personaggio deve correre: Sprint è premuto, il personaggio cammina (Humanoid.MoveDirection è il vettore nullo quando sta fermo) e c'è ancora stamina. Per iniziare a correre serve almeno MIN_TO_START (20); per continuare basta qualsiasi valore sopra 0. Senza questo margine, una barra vuota che si riempie un pochino ogni frame accenderebbe e spegnerebbe la corsa ogni frame. Il recupero parte REGEN_DELAY (1 secondo) dopo l'ultima corsa o l'ultimo scatto, quindi, dopo aver svuotato la barra, il giocatore aspetta circa 2.3 secondi prima di poter correre di nuovo.
WalkSpeed cambia solo nel frame in cui la corsa inizia o finisce. All'inizio lo script ricorda il WalkSpeed attuale e aggiunge SPRINT_BONUS; alla fine ripristina il valore ricordato. Così una velocità impostata da un altro script resta: il vantaggio Speed della guida ai game pass (in inglese) imposta WalkSpeed a 24, e con questo script chi lo possiede corre a 34. Uno script che scrive WalkSpeed = 16 ogni frame o a ogni rilascio annullerebbe di nascosto quel vantaggio.
Lo scatto
Lo scatto spinge il personaggio verso dove si muove, o verso dove guarda se è fermo, e la direzione viene appiattita così non punta mai in su o in giù. Costa 25 di stamina, mette in pausa il recupero come la corsa e ha un tempo di ricarica di 1 secondo. Non controlla il terreno, quindi funziona anche in aria, il che si combina bene con il doppio salto. Mentre il personaggio è seduto, lo scatto non fa nulla: un personaggio seduto è saldato al sedile, e in un veicolo la spinta potrebbe spostare tutto il veicolo.
La spinta è un vincolo LinearVelocity sul RootAttachment della parte radice. In modalità Plane con gli assi X e Z mantiene una velocità orizzontale di 60 stud al secondo e non tocca la verticale, quindi la gravità funziona e uno scatto da una sporgenza cade normalmente. MaxForce è math.huge, quindi la spinta non ha limiti. Debris:AddItem distrugge il vincolo dopo DASH_SECONDS senza far aspettare lo script, quindi lo scatto dura 0.2 secondi, circa 12 stud a questa velocità.
I vecchi tutorial usano BodyVelocity, che Roblox ha segnato come deprecato con l'indicazione di usare LinearVelocity al suo posto. Il suo trucco del MaxForce a zero su un asse è sostituito dalle modalità Line, Plane e Vector di LinearVelocity. Siccome il dispositivo del giocatore simula da solo il suo personaggio, un vincolo creato da un LocalScript lo muove, e gli altri giocatori vedono lo scatto come qualsiasi altro movimento.
Il tutorial UI di Roblox attacca il vincolo a humanoid.RootPart.RootAttachment esattamente allo stesso modo. Se il tuo gioco ha un personaggio personalizzato la cui parte radice non ha un Attachment chiamato RootAttachment, lo scatto non fa nulla: aggiungilo alla HumanoidRootPart del tuo StarterCharacter.
Passo 4: il doppio salto
Il doppio salto vive in un suo LocalScript in StarterCharacterScripts. Roblox mette una copia degli script di questo contenitore in ogni personaggio allo spawn, e queste copie non sopravvivono al respawn, quindi ogni vita parte con uno script nuovo e nulla passa dalla precedente.
- Nell'Explorer espandi StarterPlayer, passa il mouse su StarterCharacterScripts e inserisci un LocalScript chiamato
DoubleJump. - Sostituisci il suo contenuto con il codice qui sotto.
-- Dà un salto in più in aria. Riparte da capo per ogni nuovo personaggio,
-- quindi dopo il respawn non passa nulla.
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 scatta più volte per una sola pressione
local NEW_PRESS_GAP = 0.1 -- un tasto salto tenuto premuto continua a inviare JumpRequest; una pausa così lunga vuol dire che è stato rilasciato
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 salto da terra (non uno dei nostri salti in aria) ripristina i salti in aria
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- JumpRequest scatta quando il giocatore chiede un salto, per esempio con Space o il pulsante salto sul telefono
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Salta di nuovo solo una nuova pressione, così un tasto tenuto premuto non spreca il salto in aria
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)
Imposta EXTRA_JUMPS a 2 per un triplo salto.
Lo script segue lo stato del personaggio con Humanoid.StateChanged. Un passaggio a Jumping che non arriva da Freefall è un salto da terra, quindi concede un salto in aria, e Landed lo toglie di nuovo. Se scendi da una sporgenza, il personaggio entra in Freefall senza saltare, quindi non riceve il salto in aria. Se lo vuoi anche lì, imposta jumpsLeft anche al passaggio a Freefall da qualsiasi stato diverso da Jumping.
UserInputService.JumpRequest scatta quando il giocatore chiede un salto, per esempio con Space o il pulsante salto sul telefono. Il riferimento di Roblox avverte che scatta più volte per una sola richiesta di salto e consiglia un debounce, quindi lo script ignora le richieste per 0.25 secondi dopo l'ultimo salto. Anche un tasto salto tenuto premuto può continuare a chiedere salti e sprecherebbe il salto in aria nell'istante in cui il personaggio si stacca da terra, quindi una richiesta conta come nuova pressione solo dopo 0.1 secondi senza richieste.
Il salto in aria stesso è Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Il riferimento di Roblox dice che va chiamato da un LocalScript sul dispositivo che ha la proprietà di rete del personaggio, che per impostazione predefinita è il dispositivo del giocatore stesso, non il server. Il codice di esempio di ChangeState nel riferimento è proprio un doppio salto.
Passo 5: scoprire lo speed hack sul server
I tutorial sulla corsa spesso si fermano al client. Uno Script lato server non può fidarsi del WalkSpeed di un giocatore, perché gli exploiter lo cambiano sul loro dispositivo, ma vede dove finisce il loro personaggio. MovementCheck lo misura due volte al secondo e scrive un avviso nell'Output quando qualcuno si muove a lungo più veloce di quanto permettano corsa e scatto. I numeri di corsa e scatto li legge da MovementConfig, quindi aggiungi quel modulo del passo 2 anche se hai tenuto ShiftToSprint.
- Passa il mouse su ServerScriptService e inserisci uno Script chiamato
MovementCheck. - Sostituisci il suo contenuto con il codice qui sotto.
-- I dispositivi dei giocatori muovono i loro personaggi, quindi un exploiter può impostare qualsiasi WalkSpeed.
-- Questo controllo misura quanto si sposta davvero ogni personaggio e scrive nell'Output
-- quando qualcuno si muove a lungo più veloce di quanto permettano corsa e scatto. Si limita ad avvisare:
-- lag, teletrasporti e nastri trasportatori possono sembrare eccesso di velocità, quindi regolalo prima di punire qualcuno.
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 -- secondi
-- Velocità di corsa più un margine per il lag. Aumentalo se vendi accelerazioni.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- margine per uno o due scatti
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- quanto in fretta vengono perdonati gli scatti passati
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- la parte radice su cui è stata misurata lastPosition
local excess: { [Player]: number } = {} -- stud oltre il margine, perdonati poco a poco
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 è una nuova parte radice, e un teletrasporto dal server (inizio round, checkpoint)
-- imposta l'attributo qui sotto: ricominciamo a misurare invece di segnalare il salto
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
-- Solo movimento orizzontale: cadere veloce non è barare
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
L'avviso appare nell'Output in Studio. Nel gioco pubblicato finisce nel log del server della Developer Console, che puoi leggere come proprietario del gioco: vedi l'output nel gioco pubblicato.
Cosa misura
Ogni mezzo secondo lo script legge la posizione della parte radice di ogni personaggio e misura di quanto si è spostata in orizzontale dall'ultimo controllo. L'altezza viene ignorata, quindi cadute e salti non contano mai; il consiglio di Roblox sul controllo del movimento propone la stessa proiezione sul piano XZ per i giochi in cui si cammina a terra. Il margine è la velocità di camminata predefinita più il bonus di corsa e un altro quarto per il lag: 32.5 stud al secondo. La distanza oltre questo finisce in un «secchio bucato», un accumulatore che secondo la documentazione di Roblox funziona bene per molti sviluppatori con brevi picchi. Il secchio perde 3 stud a ogni controllo, e lo script avvisa quando contiene più di 24 stud, un margine di circa due scatti.
| Chi bara | Cosa fa MovementCheck |
|---|---|
| Imposta WalkSpeed a 100 | Avvisa dopo circa un secondo di corsa |
| Imposta WalkSpeed a 50 | Avvisa dopo circa 2.5 secondi di corsa |
| Fa scatti uno dopo l'altro senza ricarica (60 stud al secondo) | Avvisa dopo circa 1.5 secondi |
| Si teletrasporta di più di 43 stud in una volta | Avvisa al controllo successivo |
| Corre fino a 38 stud al secondo, circa una volta e mezza la velocità di corsa | Niente: sotto i 38.5 stud al secondo il secchio si svuota alla stessa velocità con cui si riempie |
| Cambia il suo MovementConfig per avere stamina infinita | Niente: correre a 26 stud al secondo è permesso per tutto il tempo che vuoi |
| Vola, salta senza limiti o attraversa i muri | Niente: il controllo ignora l'altezza e non guarda le collisioni |
Quindi il controllo prende i trucchi grossolani, in cui il giocatore è nettamente più veloce di tutti gli altri, e lascia passare quelli fatti con attenzione. È il limite onesto di un controllo basato sulla distanza e il motivo per cui Roblox sta preparando qualcosa di più forte (vedi server authority qui sotto).
Perché si limita ad avvisare
La documentazione di Roblox nota che i semplici controlli di velocità possono segnalare giocatori onesti con una connessione instabile e si rompono nei giochi con veicoli o altri movimenti complessi. Picchi di lag, nastri trasportatori, veicoli, esplosioni che sbalzano i personaggi e i tuoi stessi teletrasporti possono sembrare eccesso di velocità, quindi lo script stampa solo un avviso. Guarda l'Output mentre tu e i tuoi tester giocate normalmente, aumenta SPEED_ALLOWANCE se fa inciampare giocatori onesti, e aggiungi una punizione, per esempio riportare il giocatore indietro, solo quando il controllo resta in silenzio nel gioco normale. Se nel tuo gioco le esplosioni sbalzano i personaggi, salta anche i giocatori il cui Humanoid non ha più salute.
Respawn e teletrasporti
Un respawn crea una nuova parte radice, e lo script ricomincia a misurare quando la vede, quindi morire lontano dal punto di spawn non conta mai come eccesso di velocità. I teletrasporti fatti dai tuoi script lato server hanno bisogno di un'eccezione, come dice la documentazione di Roblox per qualsiasi gioco con teletrasporti. Dopo un teletrasporto aggiungi player:SetAttribute("MovementCheckSkip", true), e il controllo successivo inizierà a misurare dalla nuova posizione invece di segnalare il salto:
- Nel sistema di round subito dopo
character:PivotTo(...)instartRound. - Nello script dei checkpoint per obby (in inglese) subito dopo ogni
character:PivotTo(...)che porta il giocatore al suo checkpoint.
Le piattaforme e i menu della guida al teletrasporto e la piattaforma Finish della guida al primo gioco lo impostano già dopo ogni spostamento.
Conta solo il valore del server. Un attributo che il giocatore imposta sul suo dispositivo resta su quel dispositivo (vedi cosa si replica e cosa no (in inglese)), quindi chi bara non può usarlo per spegnere il controllo.
La soluzione per il futuro: server authority
La documentazione di Roblox sulla sicurezza indica il modello server authority, in beta al momento della scrittura, come il modo più affidabile per fermare gli exploit di movimento. La fonte di verità diventa il server, e i dispositivi dei giocatori comunicano solo il loro input, il che, secondo la documentazione, impedisce agli speed hack di funzionare, perché non ci si fida mai del dispositivo per comunicare la propria posizione.
Il passaggio è una riscrittura, non una regolazione. In questo modello il movimento lo calcola il server, quindi un WalkSpeed o una LinearVelocity impostati solo da un LocalScript vengono annullati quando arriva lo stato dal server. La documentazione di Roblox dice che la logica principale deve girare in funzioni RunService:BindToSimulation() in un ModuleScript che eseguono sia il client sia il server. Il modello richiede anche alcune impostazioni del Workspace, tra cui PlayerScriptsUseInputActionSystem, quindi anche i tuoi controlli passeranno all'Input Action System. Tieni la versione di questa guida finché non avrai portato corsa, stamina e scatto in quello schema. Fino ad allora, un controllo sulla distanza come questo è proprio ciò che descrive la sezione di Roblox sul controllo del movimento.
Passo 6: prova su ogni dispositivo
- Premi Play e tieni premuto Shift mentre cammini. La velocità sale da 16 a 26 stud al secondo e la barra verde in fondo allo schermo cala. Dopo circa 5 secondi è vuota e torni a camminare.
- Rilascia Shift. Dopo 1 secondo la barra inizia a riempirsi. Finché non è piena per un quinto, Shift non fa nulla.
- Premi Q mentre cammini: scatti un po' in avanti e un quarto della barra sparisce. Premi subito di nuovo Q e non succede nulla finché non passa un secondo. Se lo scatto sembra troppo corto o troppo lungo, cambia
DASH_SPEEDoDASH_SECONDSin MovementConfig. - Salta, poi premi di nuovo salto in aria per il secondo salto. Atterra e riprova: ogni salto da terra restituisce il salto in aria.
- Tieni premuto Space per tutto il salto. Deve venire fuori un salto solo, non due, perché il salto in aria richiede una nuova pressione.
- Attiva il Device Simulator in Studio (al momento della scrittura è in beta: File, Beta Features, New Device Simulator, poi riavvia Studio) oppure attiva il vecchio Device Emulator nel menu Test. Scegli un telefono e premi Play. Compaiono i pulsanti Sprint e Dash. Tieni premuto Sprint mentre sterzi, poi tieni premuto il pulsante salto per tutto il salto e controlla che il salto sia uno solo.
- Apri il Controller Emulator (Controller nella scheda Emulation o Virtual controller nel pannello del Device Simulator). Tieni premuto L3 mentre ti muovi per correre, premi B per lo scatto e A due volte per il doppio salto.
- Resetta il personaggio dal menu del gioco. La barra è di nuovo piena, nell'Output non c'è nessun avviso di MovementCheck, e se stai ancora simulando un telefono, i pulsanti Sprint e Dash sono al loro posto.
- Ora gioca come chi bara. Premi il selettore Client/Server finché l'Explorer non mostra il client, seleziona lo Humanoid del tuo personaggio nel Workspace e imposta WalkSpeed a 60 nella finestra Properties. Cammina per qualche secondo: nell'Output appare un avviso come
MovementCheck: YourName moved 60 studs/s. Rimetti 16, poi per un minuto corri e scatta normalmente e controlla che l'Output resti in silenzio. - Se nel tuo place
Workspace.PlayerScriptsUseInputActionSystemè impostato su Enabled, prova di nuovo il doppio salto: la documentazione di Roblox non dice seJumpRequestsi comporta allo stesso modo con questa impostazione.
Se non succede proprio nulla, apri la finestra Output dal menu Window di Studio e cerca un errore rosso di MovementClient, oppure guarda gli errori comuni.
Quanto veloce e per quanto: preset per tipo di gioco
La corsa giusta dipende dal gioco. Un inseguimento in un horror vuole una corsa breve e lenta che finisce nel momento peggiore; una grande mappa open world ne vuole una lunga, così i giocatori non si annoiano ad attraversarla. Questi preset usano gli stessi script e cambiano solo la velocità di camminata e MovementConfig. Sono i nostri punti di partenza, calcolati dalle impostazioni, non misurati sui giocatori.
| Tipo di gioco | CharacterWalkSpeed | SPRINT_BONUS (velocità di corsa) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Corsa completa | Da vuota a piena | Distanza con una barra |
|---|---|---|---|---|---|---|---|
| Questa guida | 16 | 10 (26) | 20 | 15 | 5 s | 7.7 s | 130 stud |
| Inseguimento horror | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 stud |
| Battleground e combattimento | 16 | 12 (28) | 15 | 20 | 6.7 s | 6 s | circa 187 stud |
| Open world o simulatore | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 stud |
| Obby o parkour | 16 | 8 (24) | senza stamina: usa ShiftToSprint |
- La velocità di camminata si imposta in StarterPlayer. Seleziona StarterPlayer e imposta
CharacterWalkSpeed(predefinito 16). Ogni nuovo personaggio parte con questa velocità, la corsa le aggiungeSPRINT_BONUS, e anche MovementCheck la legge, quindi il controllo sul server segue la tua scelta. - MovementCheck si adatta. Permette la velocità di camminata più il bonus di corsa e un altro quarto per il lag: 25 stud al secondo per il preset horror, 40 per l'open world. Non serve cambiare altro.
- Negli obby la corsa cambia il percorso. Con una corsa più veloce si superano vuoti più lunghi. Costruisci i salti e poi prova ognuno alla velocità di corsa, altrimenti la corsa renderà le fasi troppo facili. La guida ai checkpoint per obby (in inglese) si combina bene con ShiftToSprint.
- Negli horror il riferimento è il killer. Rendi l'inseguitore un po' più veloce della camminata e un po' più lento della corsa, così la fuga dipende da quando finisce la barra. La guida al gioco horror spiega il resto del ciclo.
Cosa non va nei vecchi script di corsa
I vecchi tutorial su corsa, scatto e doppio salto spesso funzionano ancora, ma molti usano tecniche che Roblox ha poi sostituito, o rompono altri sistemi del tuo gioco. Se stai sistemando uno script copiato, confrontalo con questo elenco.
| Tecnica | Qual è il problema | Questa guida |
|---|---|---|
BodyVelocity per lo scatto | Deprecato: Roblox dice di usare LinearVelocity al suo posto | LinearVelocity in modalità Plane |
Ciclo su RunService.RenderStepped | Per il lavoro nuovo è stato sostituito da PreRender. La logica di gioco come la stamina va su Heartbeat, che Roblox indica per i compiti periodici come il recupero della salute | Heartbeat con deltaTime |
Ciclo della stamina con wait() | wait() è deprecato a favore di task.wait() e viene rallentato, quindi può aspettare più del richiesto, e un consumo fisso a ogni wait consuma la stamina in modo irregolare | Consumo e recupero ogni frame tenendo conto di deltaTime |
UserInputService.InputBegan senza controllo della chat | Premere Shift mentre scrivi un messaggio in chat fa partire la corsa | ContextActionService, che in più aggiunge un pulsante sul telefono |
WalkSpeed = 16 al rilascio o ogni frame | Sovrascrive qualsiasi altra velocità, per esempio il vantaggio di un game pass | Cambia WalkSpeed solo all'inizio e alla fine della corsa, aggiungendo al valore attuale |
| Corsa tramite RemoteEvent, così il WalkSpeed lo imposta il server | Gli exploiter si impostano comunque il WalkSpeed da soli, e la corsa parte con il ritardo di un viaggio di andata e ritorno | Corsa sul client più un controllo della distanza sul server |
Doppio salto a ogni JumpRequest | JumpRequest scatta più volte per una sola richiesta di salto, e un tasto tenuto premuto può continuare a chiedere salti | Pausa di 0.25 secondi e controllo della nuova pressione |
UserInputService.TouchEnabled come controllo «è un telefono» | È true sui portatili con touch screen | ContextActionService aggiunge pulsanti sullo schermo sui dispositivi touch senza un tuo controllo del dispositivo |
Humanoid:LoadAnimation per l'animazione di corsa | Deprecato a favore di Animator:LoadAnimation | L'animazione di corsa qui sotto usa Animator |
Il nuovo metodo di Roblox: Input Action System
La pagina di Roblox sull'Input Action System usa la corsa del personaggio come primo esempio. Invece delle chiamate BindAction, i controlli si configurano in Studio: una InputAction chiamata CharacterSprint dentro un input context in ReplicatedStorage, con un InputBinding per Left Shift, uno per il pulsante Y del gamepad e uno collegato a un pulsante sullo schermo che disegni in StarterGui. Poi uno script client ascolta gli eventi Pressed e Released dell'azione, raddoppiando il WalkSpeed alla pressione e ripristinandolo al rilascio.
Conviene passarci se vuoi disporre i controlli in Studio invece che nel codice, un pulsante touch tuo invece di quello di ContextActionService, o contesti che cambiano interi set di controlli, per esempio per menu o veicoli. La pagina consiglia anche di impostare Workspace.PlayerScriptsUseInputActionSystem su Enabled, e server authority lo richiede.
Il ciclo della stamina e lo scatto di questa guida funzionano allo stesso modo con il solo Input Action System (senza server authority). Tieni MovementConfig, il ciclo Heartbeat e dash(), elimina le due chiamate BindAction e i loro gestori, e collega al loro posto le azioni: Pressed dell'azione di corsa imposta sprintHeld a true e il suo Released a false, e Pressed dell'azione di scatto chiama dash(). Continua a cercare lo Humanoid ogni frame, come fa MovementClient, perché l'esempio della documentazione salva lo Humanoid del primo personaggio, che dopo il respawn non esiste più.
Roblox sta anche testando la Character Controller Library, una beta che si attiva in Beta Features e Avatar Settings in Studio. La sua pagina sulle abilità personalizzate costruisce come esempio uno scatto con una finestra attiva di 0.2 secondi e una ricarica di 1 secondo, cioè con gli stessi tempi dello scatto di questa guida.
Come estenderlo: animazione, camera e pass per la corsa
Animazione di corsa
Crea un'animazione di corsa nell'Animation Editor, dalle priorità Movement (Roblox la consiglia per le animazioni di camminata e corsa), pubblicala e copia l'ID dell'asset. In MovementClient crea una Animation con questo AnimationId, caricala con Animator:LoadAnimation usando l'Animator dentro lo Humanoid del personaggio, avvia la traccia dove inizia la corsa e fermala dove finisce. Caricala di nuovo per ogni nuovo personaggio.
Le animazioni che il tuo dispositivo avvia sul tuo personaggio le vedono tutti, se usi l'Animator che ci ha messo Roblox: le tracce caricate su un Animator creato da un LocalScript non si replicano. Humanoid:LoadAnimation, usato da molti vecchi tutorial, è deprecato.
Camera più larga durante la corsa
Un campo visivo un po' più largo fa sembrare la corsa più veloce. Negli stessi due punti fai un tween di workspace.CurrentCamera.FieldOfView dal valore predefinito 70 fino a circa 80 quando la corsa inizia, e indietro quando finisce, per esempio con TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox limita il valore tra 1 e 120 e avverte che valori molto bassi o molto alti possono disorientare i giocatori. Se un altro script del gioco cambia il campo visivo, torna al valore che hai trovato, non a 70.
Corsa veloce come game pass
La guida ai game pass (in inglese) funziona già con questo script: il suo vantaggio Speed sul server imposta WalkSpeed a 24 per ogni nuovo personaggio, MovementClient ci aggiunge sopra il bonus di corsa, e 34 stud al secondo restano entro ciò che permette MovementCheck.
Per un pass che rende più veloce la corsa stessa, aggiungi un pass FastSprint a PassConfig.ids di quella guida. Il suo script lato server allora dà al giocatore l'attributo OwnsPass_FastSprint appena l'acquisto è confermato. In MovementClient usa un bonus più grande di Config.SPRINT_BONUS quando player:GetAttribute("OwnsPass_FastSprint") == true. In MovementCheck dai a questi giocatori un margine più ampio leggendo lo stesso attributo sul server, dove il giocatore non può cambiarlo, e controlla che la nuova velocità massima resti sotto quella che il controllo segnala.
Un limite da conoscere: se un altro script cambia il WalkSpeed a metà corsa, la fine di quella corsa ripristina la velocità di prima. Il respawn successivo imposta di nuovo la velocità del pass, perché lo script dei game pass la applica a ogni nuovo personaggio.
Errori comuni e soluzioni
Apri la finestra Output (menu Window, poi Output) prima di premere Play. La maggior parte dei problemi con questi script stampa lì un errore o un avviso con il nome dello script e il numero di riga.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
MovementClient o MovementCheck aspetta un modulo che non esiste con esattamente quel nome. Deve essere un ModuleScript chiamato MovementConfig direttamente dentro ReplicatedStorage. La guida agli errori degli script spiega questo avviso nel dettaglio.
Shift non fa nulla
Controlla che ShiftToSprint o MovementClient sia un LocalScript, non uno Script, e che sia in StarterPlayerScripts. Con MovementClient, per iniziare a correre il personaggio deve anche camminare e avere almeno 20 di stamina, quindi tieni premuto Shift mentre ti muovi. Se invece della corsa si attiva Shift Lock, vedi la domanda su Shift Lock qui sotto.
La corsa si ferma dopo pochi secondi
È la stamina che finisce: 100 di stamina a 20 al secondo bastano per 5 secondi. Aumenta MAX_STAMINA o riduci DRAIN_PER_SECOND in MovementConfig.
Lo scatto non fa nulla
Lo scatto richiede 25 di stamina, aspetta 1 secondo dal precedente e non fa nulla mentre sei seduto. Se non è questo, la parte radice del tuo personaggio potrebbe non avere un Attachment chiamato RootAttachment, come succede con alcuni personaggi personalizzati: aggiungilo alla HumanoidRootPart del tuo StarterCharacter.
Il doppio salto non funziona
DoubleJump deve essere un LocalScript in StarterCharacterScripts, non in StarterPlayerScripts, perché legge script.Parent come personaggio. Premi salto una seconda volta dopo esserti staccato da terra: un tasto tenuto premuto non conta come nuova pressione, e scendere da una sporgenza non dà il salto in aria.
Sul telefono non c'è il pulsante Sprint o Dash
ContextActionService aggiunge i suoi pulsanti solo sui dispositivi touch, quindi su un PC senza touch screen non si vedono mai. Prova con un telefono nel Device Simulator di Studio (è in beta: attiva New Device Simulator in File, Beta Features e riavvia Studio). BindAction può creare al massimo 7 pulsanti touch, quindi conta quanti ne creano gli altri script del gioco.
MovementCheck segnala giocatori onesti
Le cause tipiche: un teletrasporto da un altro script lato server, un nastro trasportatore o un veicolo, oppure il lag. Imposta l'attributo MovementCheckSkip dopo i tuoi teletrasporti (vedi Respawn e teletrasporti) e aumenta SPEED_ALLOWANCE se il controllo scatta ancora nel gioco normale.
L'accelerazione sparisce dopo la corsa
Un altro script ha cambiato il WalkSpeed durante la corsa, e la corsa, finendo, ha ripristinato la velocità che vedeva all'inizio. Dai le accelerazioni allo spawn del personaggio, come fa la guida ai game pass, così il respawn reimposta la velocità giusta.
Fallo con RoCode
Se non hai voglia di configurare tutto questo a mano, RoCode può costruirlo nel place che hai aperto. RoCode è un agente IA indipendente per Roblox Studio, non di Roblox: descrivi la modifica nella chat web e il suo plugin per Studio crea gli script nel tuo Explorer, quindi non devi incollare codice.
Aggiungi la corsa con Shift con una barra della stamina: velocità di camminata più 10 finché Shift è premuto, 100 di stamina, consumo di 20 al secondo, recupero di 15 al secondo dopo un secondo di riposo, un pulsante Sprint sui telefoni, uno scatto su Q e un doppio salto.
- Può prima esaminare il tuo place con Search Scripts e Read Script per trovare altri script che cambiano il WalkSpeed (per esempio il vantaggio di un game pass), così la corsa si aggiunge a quelli
- Scrive il ModuleScript, i LocalScript e il controllo sul server con Create Script
- Ha l'istruzione di verificare la compilazione di ogni script che scrive con Check Script, che lo compila in Studio senza eseguirlo
- Mette un punto di annullamento prima e dopo ogni gruppo di modifiche, quindi Ctrl+Z annulla un gruppo alla volta
RoCode non sa creare l'animazione di corsa: creala nell'Animation Editor e incolla il suo ID. Con il plugin 3.9.11 o più recente RoCode può avviare un playtest del tuo gioco in Studio e guidare un personaggio di prova per controllare che tutto funzioni, e con il plugin 3.9.15 o più recente il personaggio di prova può premere tasti, per esempio tenere premuto Shift e controllare che il WalkSpeed sia salito. Decide da solo quando avviare un playtest, fino a 2 per build più 1 per controllare la sua correzione, e controlla solo ciò che ha deciso di testare, quindi prova tu corsa, scatto e doppio salto, e verifica i pulsanti del telefono nel Device Simulator di Studio. Il movimento è uno dei tanti sistemi di un gioco; creare un gioco intero con RoCode procede un sistema per prompt, come qui. Come RoCode si collega a Studio.
Domande frequenti
Perché lo script di corsa non funziona sul telefono?
Il telefono non ha il tasto Shift. Collega la corsa con ContextActionService:BindAction e passa true come terzo argomento: aggiunge un pulsante sullo schermo sui dispositivi touch, come fanno sia ShiftToSprint sia MovementClient.
La corsa va fatta sul server?
No. Ogni dispositivo muove il proprio personaggio, quindi un WalkSpeed impostato dal server non ferma chi bara, che può impostare il suo, e la nuova velocità arriva solo dopo un viaggio di andata e ritorno, quindi la corsa parte in ritardo. Fai la corsa sul client e controlla sul server quanto si spostano davvero i personaggi, come nel passo 5. La beta server authority di Roblox funziona diversamente, e per quella il codice del movimento andrà riscritto.
Perché il personaggio continua a correre quando ho rilasciato Shift?
Lo script ha perso il rilascio, di solito perché ascolta solo la pressione. ContextActionService invia End quando il tasto viene rilasciato e Cancel quando lo prende un altro collegamento; MovementClient si ferma con entrambi, e anche quando finisce la stamina o il personaggio smette di muoversi.
Come aggiungo un'animazione di corsa?
Carica un'animazione di corsa tramite l'Animator nello Humanoid del personaggio nello stesso LocalScript, avviala quando la corsa inizia e fermala quando finisce. Dalle priorità Movement. Le animazioni avviate sul tuo personaggio le vedono tutti.
Perché il doppio salto sul telefono parte da solo?
Un pulsante salto tenuto premuto sul telefono continua a chiedere salti. Considera un salto nuovo solo se le richieste si sono fermate per un attimo, come fa lo script DoubleJump.
Qual è la velocità di camminata predefinita su Roblox?
16 stud al secondo. Viene da StarterPlayer.CharacterWalkSpeed, che imposta lo Humanoid.WalkSpeed di ogni nuovo personaggio. La corsa di questa guida aggiunge 10, quindi la corsa va a 26.
Quanto deve essere veloce la corsa su Roblox?
La maggior parte dei giochi aggiunge da metà a un'intera velocità di camminata: 16 diventa qualcosa tra 24 e 32. Una corsa breve e lenta si adatta agli horror, una lunga e veloce alle mappe grandi. I preset per tipo di gioco danno per ognuno velocità di camminata, bonus di corsa e numeri della stamina.
Come faccio una corsa con la stamina?
Tieni un numero di stamina sul dispositivo del giocatore, consumalo ogni frame durante la corsa e recuperalo dopo un breve riposo, in entrambi i casi tenendo conto del tempo del frame, e ferma la corsa quando arriva a 0. MovementClient del passo 3 fa questo con una barra sullo schermo; i numeri sono in MovementConfig.
Come si corre con il controller su Roblox?
Collega ButtonL3 del gamepad (la pressione della levetta sinistra) tramite ContextActionService insieme a Left Shift, come fanno entrambi gli script qui. ShiftToSprint fa di L3 un interruttore, perché tenere la levetta premuta e intanto sterzare con essa è faticoso.
La corsa con Shift va in conflitto con Shift Lock?
Può succedere. I giocatori che hanno attivato Shift Lock nelle impostazioni di Roblox lo attivano e disattivano con il tasto Shift, quindi un solo tasto fa due cose. La documentazione di Roblox dice che le API di Shift Lock stanno per essere ritirate. Se il conflitto dà fastidio ai tuoi giocatori, disattiva StarterPlayer.EnableMouseLockOption o collega la corsa in MovementClient a un altro tasto, per esempio Left Ctrl.
Fonti e letture
- Roblox Creator Docs: ContextActionService (in inglese). BindAction, pulsanti touch, il limite di 7 pulsanti e perché nella maggior parte dei casi è meglio di InputBegan
- Roblox Creator Docs: Humanoid (in inglese). WalkSpeed e la nota sulla sicurezza, MoveDirection, StateChanged e ChangeState con l'esempio del doppio salto
- Roblox Creator Docs: LinearVelocity (in inglese). modalità Plane, assi tangenti e MaxForce
- Roblox Creator Docs: Mover constraints (in inglese). il passaggio dal deprecato BodyVelocity a LinearVelocity
- Roblox Creator Docs: UserInputService (in inglese). JumpRequest e perché gli serve un debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (in inglese). cosa controlla il client, controlli della distanza, secchi bucati ed eccezioni per i teletrasporti
- Roblox Creator Docs: Server authority model (in inglese). il modello con il movimento sul server, BindToSimulation e le impostazioni del Workspace che richiede
- Roblox Creator Docs: Input Action System (in inglese). l'esempio Character Sprint con InputAction e InputBinding
- Roblox Creator Docs: Custom abilities (in inglese). l'abilità di scatto nella Character Controller Library
- Roblox Creator Docs: Studio testing modes (in inglese). Device Simulator e Controller Emulator
Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.