Tutorial · Sistemi di gioco

Come correre con Shift in Roblox Studio su PC, telefono e console

Correre con Shift su Roblox si riduce a un solo numero: il WalkSpeed dello Humanoid, che sale finché Shift è premuto. Il passo 1 fa esattamente questo in un breve LocalScript, che funziona anche con il pulsante Sprint sul telefono e con il gamepad. Il resto della guida aggiunge ciò che serve a un gioco più grande: una barra della stamina, uno scatto con la fisica moderna, un doppio salto che non parte tenendo premuto il tasto, e un'idea chiara di cosa il server può controllare e cosa no.

Aggiornato il 20 novembre 202628 min di letturaScritto da

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
  1. Come funziona
  2. 1. Corsa con Shift
  3. 2. Modulo impostazioni
  4. 3. Corsa e scatto
  5. 4. Doppio salto
  6. 5. Controllo sul server
  7. 6. Prova
  8. Preset di velocità
  9. Vecchi script
  10. Input Action System
  11. Estensioni
  12. Common errors
  13. Con RoCode
  14. Domande frequenti
  15. Fonti e letture

Come funziona la corsa su Roblox

IllustrazioneShift fa correre con WalkSpeed 26 mentre la barra cala, Q fa uno scatto al costo di un quarto della barra, e una seconda pressione del salto in aria salta ancora.

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.

Di cosa è fatto il sistema di movimento
ElementoDove si trovaCosa fa
LocalScript ShiftToSprintStarterPlayerScriptsIl passo 1 da solo: corsa su tastiera, telefono e gamepad, senza stamina. Quando aggiungi stamina e scatto, lo sostituisce MovementClient.
ModuleScript MovementConfigReplicatedStorageI numeri: bonus di corsa, stamina e scatto. Li leggono sia il LocalScript sia il controllo sul server.
LocalScript MovementClientStarterPlayerScriptsCollega 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 DoubleJumpStarterCharacterScriptsDà un salto in più in aria. Una nuova copia parte in ogni nuovo personaggio.
Script MovementCheckServerScriptServiceMisura 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.
L'Explorer quando il sistema di movimento è pronto
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.

  1. Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts, clicca sul pulsante + e inserisci un LocalScript chiamato ShiftToSprint.
  2. Sostituisci il suo contenuto con il codice qui sotto e premi Play.
LocalScript in StarterPlayerScripts chiamato ShiftToSprint
-- 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?

Come funziona ShiftToSprint su ogni dispositivo quando TOGGLE_ON_TOUCH_AND_GAMEPAD è true
Dispositivo e inputFunziona comePerché
Tastiera: Left ShiftTenere premutoTenere premuto il tasto mentre ti muovi è facile, e al rilascio la corsa si ferma subito.
Gamepad: pressione della levetta sinistra (L3)Attiva/disattivaTenere la levetta premuta e intanto sterzare con essa è faticoso.
Telefono o tablet: pulsante Sprint sullo schermoAttiva/disattivaIl 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.

  1. Nell'Explorer passa il mouse su ReplicatedStorage, clicca sul pulsante + e inserisci un ModuleScript.
  2. Rinominalo in MovementConfig e sostituisci il contenuto con il codice qui sotto.
ModuleScript in ReplicatedStorage chiamato MovementConfig
-- 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
Cosa fa ogni impostazione
ImpostazioneValoreEffetto
SPRINT_BONUS10Si aggiunge al WalkSpeed durante la corsa. Il WalkSpeed predefinito di Roblox è 16, quindi la corsa va a 26 stud al secondo.
MAX_STAMINA100La barra piena.
DRAIN_PER_SECOND20La barra piena basta per 5 secondi di corsa.
REGEN_PER_SECOND15La barra vuota si riempie in circa 6.7 secondi.
REGEN_DELAY1Secondi di riposo prima che inizi il recupero.
MIN_TO_START20Stamina necessaria per iniziare a correre.
DASH_SPEED60Stud al secondo durante lo scatto.
DASH_SECONDS0.2Quanto dura lo scatto: circa 12 stud a 60 stud al secondo.
DASH_COST25Stamina per ogni scatto.
DASH_COOLDOWN1Secondi 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.

  1. Nell'Explorer espandi StarterPlayer, passa il mouse su StarterPlayerScripts e inserisci un LocalScript chiamato MovementClient.
  2. Sostituisci il suo contenuto con il codice qui sotto.
LocalScript in StarterPlayerScripts chiamato MovementClient
-- 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.

  1. Nell'Explorer espandi StarterPlayer, passa il mouse su StarterCharacterScripts e inserisci un LocalScript chiamato DoubleJump.
  2. Sostituisci il suo contenuto con il codice qui sotto.
LocalScript in StarterCharacterScripts chiamato DoubleJump
-- 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.

  1. Passa il mouse su ServerScriptService e inserisci uno Script chiamato MovementCheck.
  2. Sostituisci il suo contenuto con il codice qui sotto.
Script in ServerScriptService chiamato MovementCheck
-- 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.

Cosa prende il controllo, calcolato con i suoi numeri
Chi baraCosa fa MovementCheck
Imposta WalkSpeed a 100Avvisa dopo circa un secondo di corsa
Imposta WalkSpeed a 50Avvisa 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 voltaAvvisa al controllo successivo
Corre fino a 38 stud al secondo, circa una volta e mezza la velocità di corsaNiente: 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 infinitaNiente: correre a 26 stud al secondo è permesso per tutto il tempo che vuoi
Vola, salta senza limiti o attraversa i muriNiente: 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:

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

  1. 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.
  2. Rilascia Shift. Dopo 1 secondo la barra inizia a riempirsi. Finché non è piena per un quinto, Shift non fa nulla.
  3. 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_SPEED o DASH_SECONDS in MovementConfig.
  4. Salta, poi premi di nuovo salto in aria per il secondo salto. Atterra e riprova: ogni salto da terra restituisce il salto in aria.
  5. Tieni premuto Space per tutto il salto. Deve venire fuori un salto solo, non due, perché il salto in aria richiede una nuova pressione.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. Se nel tuo place Workspace.PlayerScriptsUseInputActionSystem è impostato su Enabled, prova di nuovo il doppio salto: la documentazione di Roblox non dice se JumpRequest si 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.

Velocità di camminata, corsa e stamina per tipo di gioco. Il tempo di corsa è MAX_STAMINA / DRAIN_PER_SECOND; il recupero è MAX_STAMINA / REGEN_PER_SECOND più 1 secondo di REGEN_DELAY
Tipo di giocoCharacterWalkSpeedSPRINT_BONUS (velocità di corsa)DRAIN_PER_SECONDREGEN_PER_SECONDCorsa completaDa vuota a pienaDistanza con una barra
Questa guida1610 (26)20155 s7.7 s130 stud
Inseguimento horror128 (20)25104 s11 s80 stud
Battleground e combattimento1612 (28)15206.7 s6 scirca 187 stud
Open world o simulatore1616 (32)102510 s5 s320 stud
Obby o parkour168 (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 aggiunge SPRINT_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.

Tecniche dei vecchi tutorial e cosa fa invece questa guida
TecnicaQual è il problemaQuesta guida
BodyVelocity per lo scattoDeprecato: Roblox dice di usare LinearVelocity al suo postoLinearVelocity in modalità Plane
Ciclo su RunService.RenderSteppedPer 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 saluteHeartbeat 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 irregolareConsumo e recupero ogni frame tenendo conto di deltaTime
UserInputService.InputBegan senza controllo della chatPremere Shift mentre scrivi un messaggio in chat fa partire la corsaContextActionService, che in più aggiunge un pulsante sul telefono
WalkSpeed = 16 al rilascio o ogni frameSovrascrive qualsiasi altra velocità, per esempio il vantaggio di un game passCambia WalkSpeed solo all'inizio e alla fine della corsa, aggiungendo al valore attuale
Corsa tramite RemoteEvent, così il WalkSpeed lo imposta il serverGli exploiter si impostano comunque il WalkSpeed da soli, e la corsa parte con il ritardo di un viaggio di andata e ritornoCorsa sul client più un controllo della distanza sul server
Doppio salto a ogni JumpRequestJumpRequest scatta più volte per una sola richiesta di salto, e un tasto tenuto premuto può continuare a chiedere saltiPausa di 0.25 secondi e controllo della nuova pressione
UserInputService.TouchEnabled come controllo «è un telefono»È true sui portatili con touch screenContextActionService aggiunge pulsanti sullo schermo sui dispositivi touch senza un tuo controllo del dispositivo
Humanoid:LoadAnimation per l'animazione di corsaDeprecato a favore di Animator:LoadAnimationL'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.

Tu scrivi

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.

RoCode fa
  • 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

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.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.