In breve
Prendi il servizio con game:GetService("TweenService"), descrivi il movimento con TweenInfo.new(time, easingStyle, easingDirection), poi chiama TweenService:Create(part, info, { Position = goal }) e avvia :Play() sul tween che ottieni. Puoi fare il tween di qualsiasi proprietà di tipo number, Vector3, CFrame, Color3, UDim2 e simili. Per aspettare la fine usa tween.Completed:Wait(), e per un movimento avanti e indietro senza fine imposta in TweenInfo il numero di ripetizioni a -1 e attiva reverses.
- Fai il tween della parte sul server quando devono vederla tutti i giocatori; sul client quando l'effetto serve solo a quel giocatore.
- Ancora (Anchored) le parti di cui fai il tween, altrimenti la fisica disturba il tween.
- Un Model non ha Position o CFrame da animare: fai il tween di un NumberValue e muovi il modello con
PivotTo.
In questa pagina
Le tre righe che servono a ogni tween
Inserisci una Part nel Workspace, spunta Anchored, poi passaci sopra con il mouse, clicca su + e inserisci uno Script. Questo script alza la parte di 10 stud in 2 secondi:
-- Script dentro una Part.
local TweenService = game:GetService("TweenService")
local part = script.Parent :: BasePart
local info = TweenInfo.new(2) -- 2 secondi, easing predefinito
local goal = { Position = part.Position + Vector3.new(0, 10, 0) }
local tween = TweenService:Create(part, info, goal)
tween:Play()
L'obiettivo è una tabella con i nomi delle proprietà e i valori a cui devono arrivare. Puoi fare il tween di più proprietà insieme: { Position = ..., Transparency = 1, Color = Color3.fromRGB(255, 0, 0) }. Il tween parte dai valori presenti nel momento in cui chiami Play, quindi indichi sempre solo la fine.
| Tipo | Tween fluido? | Esempi |
|---|---|---|
| number | Sì | Transparency, Reflectance, Value di un NumberValue |
| Vector3, CFrame | Sì | Position, Size, CFrame, Orientation |
| Color3 | Sì | Color |
| UDim2, Vector2 | Sì | Size e Position delle GUI |
| boolean, EnumItem | Cambia alla fine | CanCollide, Material |
| string, Instance | No | Dà l'errore cannot be tweened due to type mismatch |
Passo 1: tutte le impostazioni di TweenInfo
TweenInfo.new accetta fino a sei valori, in questo ordine. Gli ultimi si possono omettere.
| Valore | Predefinito | Cosa fa |
|---|---|---|
time | 1 | Secondi per una riproduzione. |
easingStyle | Quad | La forma del movimento: Linear (velocità costante), Sine, Quad, Cubic, Back (va oltre e torna), Bounce, Elastic, Exponential. |
easingDirection | Out | Out parte veloce e rallenta; In parte lento; InOut fa entrambe le cose. |
repeatCount | 0 | Quante volte ripetere dopo la prima riproduzione. -1 ripete all'infinito. |
reverses | false | Tornare all'inizio dopo ogni riproduzione. |
delayTime | 0 | Quanti secondi aspettare prima di partire. |
-- Script dentro una Part chiamata Platform.
-- Va avanti e indietro all'infinito di 12 stud, in modo fluido a entrambe le estremità.
local TweenService = game:GetService("TweenService")
local platform = script.Parent :: BasePart
local info = TweenInfo.new(
3, -- secondi per ogni direzione
Enum.EasingStyle.Sine,
Enum.EasingDirection.InOut,
-1, -- ripeti all'infinito
true -- torna indietro ogni volta
)
TweenService:Create(platform, info, { Position = platform.Position + Vector3.new(12, 0, 0) }):Play()
Se la piattaforma deve trasportare i giocatori che ci stanno sopra, tieni presente che una parte ancorata animata con un tween si muove sotto di loro ma non li porta con sé. Questo caso è spiegato nella guida alla piattaforma mobile.
Passo 2: rotazione, dimensione e dissolvenza
Per ruotare una parte, fai il tween del CFrame verso il CFrame attuale moltiplicato per una rotazione. Anche il tween di Orientation funziona, ma con il CFrame la parte ruota sul posto. Qui il muro, all'avvio dello script, ruota, poi svanisce e si rimpicciolisce, e alla fine del tween viene eliminato:
-- Script dentro una Part chiamata FadingWall.
local TweenService = game:GetService("TweenService")
local wall = script.Parent :: BasePart
-- un quarto di giro attorno al proprio asse verticale in 1 secondo
local turn = TweenService:Create(wall, TweenInfo.new(1), {
CFrame = wall.CFrame * CFrame.Angles(0, math.rad(90), 0),
})
turn:Play()
turn.Completed:Wait() -- continuiamo solo quando la rotazione è finita
-- poi lo facciamo svanire e rimpicciolire insieme
local fade = TweenService:Create(wall, TweenInfo.new(0.8, Enum.EasingStyle.Quad, Enum.EasingDirection.In), {
Transparency = 1,
Size = wall.Size * 0.2,
})
fade:Play()
fade.Completed:Wait()
wall:Destroy()
Completed scatta con un PlaybackState: Completed se il tween ha raggiunto l'obiettivo, oppure Cancelled se l'ha fermato tween:Cancel(). Non aspettare Completed su un tween che si ripete all'infinito: non finirà mai.
Passo 3: un oggetto che fluttua e ruota
Due tween in ciclo su proprietà diverse vanno insieme. Un tween di un giro completo di 360 gradi con il CFrame non fa nulla, perché inizio e fine sono la stessa rotazione, quindi la rotazione anima un NumberValue da 0 a 360 e imposta il CFrame in base a quello. Metti questo Script in una parte ancorata:
-- Script dentro una Part chiamata Gem. Fluttua su e giù e ruota all'infinito.
local TweenService = game:GetService("TweenService")
local FLOAT_HEIGHT = 1.5 -- stud sopra il punto in cui l'hai messo
local FLOAT_SECONDS = 1.2 -- per ogni direzione
local SPIN_SECONDS = 3 -- un giro completo
local gem = script.Parent :: BasePart
gem.Anchored = true
local baseCFrame = gem.CFrame
local height = Instance.new("NumberValue")
local angle = Instance.new("NumberValue")
local function apply()
gem.CFrame = baseCFrame * CFrame.new(0, height.Value, 0) * CFrame.Angles(0, math.rad(angle.Value), 0)
end
height.Changed:Connect(apply)
angle.Changed:Connect(apply)
TweenService:Create(height, TweenInfo.new(FLOAT_SECONDS, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true), {
Value = FLOAT_HEIGHT,
}):Play()
TweenService:Create(angle, TweenInfo.new(SPIN_SECONDS, Enum.EasingStyle.Linear, Enum.EasingDirection.In, -1), {
Value = 360,
}):Play()
La rotazione usa l'easing Linear, quindi gira a velocità costante, e ogni ciclo ricomincia da 0, che è lo stesso angolo di 360, quindi non c'è nessuno scatto. La guida alla raccolta di monete inserisce oggetti come questo in un gioco.
Passo 4: il tween di un modello intero
Un Model non ha la proprietà Position o CFrame, quindi TweenService:Create(model, ...) non ha niente da muovere. Fai invece il tween di un NumberValue da 0 a 1 e muovi il modello con PivotTo, che sposta insieme tutte le parti al suo interno:
-- Script dentro un Model chiamato Elevator.
-- Muove tutto il modello di 20 stud in su e indietro, tutte le parti insieme.
local TweenService = game:GetService("TweenService")
local elevator = script.Parent :: Model
local startPivot = elevator:GetPivot()
local endPivot = startPivot * CFrame.new(0, 20, 0)
local progress = Instance.new("NumberValue")
progress.Changed:Connect(function(alpha: number)
elevator:PivotTo(startPivot:Lerp(endPivot, alpha))
end)
local info = TweenInfo.new(4, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut, -1, true, 2)
TweenService:Create(progress, info, { Value = 1 }):Play()
Ancora tutte le parti del modello. Il 2 alla fine di TweenInfo è il ritardo prima di ogni riproduzione, quindi l'ascensore si ferma in cima e in fondo. La guida alle porte apre allo stesso modo porte fatte di più parti.
Server o client?
Un tween avviato in uno Script del server cambia la parte sul server, e i nuovi valori si replicano a tutti i giocatori, quindi lo vedono tutti. Un tween in un LocalScript cambia la parte solo sullo schermo di quel giocatore.
| Avvialo in | Quando | Esempio |
|---|---|---|
| Uno Script del server | La modifica conta per il gioco o per tutti. | Porte, ostacoli in movimento, un ponte che si apre |
| LocalScript | Deve vederla solo quel giocatore, o è un effetto puramente visivo. | Un oggetto che svanisce per il giocatore che l'ha raccolto, la UI |
La replica invia aggiornamenti molte volte al secondo, quindi alla maggior parte dei giocatori i tween del server sembrano fluidi, ma tween del server molto veloci o molto numerosi possono sembrare meno fluidi con una connessione lenta. Per tanto movimento decorativo (centinaia di monete che ruotano) avvia i tween in un LocalScript su ogni client.
Errori comuni e soluzioni
Apri la finestra Output (menu Window, poi Output) prima di premere Play.
La parte non si muove per niente
Controlla di aver chiamato :Play() sul tween, che il nome della proprietà nell'obiettivo sia scritto esattamente (Position, non position) e che sia uno Script in un punto dove gli script vengono eseguiti (dentro una parte nel Workspace o in ServerScriptService).
La parte cade o trema durante il tween
Non è ancorata, quindi gravità e collisioni disturbano il tween. Spunta Anchored.
TweenService:Create property cannot be tweened due to type mismatch
Il valore dell'obiettivo è del tipo sbagliato, per esempio un numero per una proprietà di tipo Vector3. Guarda la pagina dell'errore (in inglese).
Unable to cast to Dictionary o Unable to cast value to Object
Gli argomenti sono nell'ordine sbagliato o del tipo sbagliato. L'ordine è sempre Create(instance, tweenInfo, goalTable). Guarda Unable to cast value to Object (in inglese).
Fallo con RoCode
Se non hai voglia di scrivere i tween a mano, RoCode può costruirli 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 serve incollare codice.
Fai scorrere di lato di 15 stud il modello del ponte nel Workspace quando inizia il round, con un tween di un NumberValue e PivotTo, e nello stesso momento fai svanire in 1 secondo le parti rosse che fanno da barriera.
- Può trovare le parti e i modelli giusti con Search Game prima di scrivere qualcosa
- Scrive lo Script con Create Script, e ha l'istruzione di verificare che compili con Check Script
- Mette un punto di annullamento prima e dopo ogni gruppo di modifiche, quindi Ctrl+Z annulla un gruppo alla volta
Con il plugin 3.9 o più recente RoCode può avviare un breve playtest e leggere gli errori, ma il movimento si giudica meglio con i propri occhi, quindi premi Play e guarda. Come RoCode si collega a Studio.
Domande frequenti
Come si usa TweenService su Roblox?
Prendi il servizio, crea un TweenInfo, chiama TweenService:Create(object, info, { Property = goal }) e avvia :Play() sul risultato. Nella prima sezione c'è un esempio di tre righe.
Come si ripete un tween per sempre?
Passa -1 come quarto valore di TweenInfo.new (repeatCount) e true come quinto, se deve andare avanti e indietro.
Come si aspetta la fine di un tween?
Chiama tween.Completed:Wait() dopo tween:Play() oppure collega una funzione a tween.Completed.
Si può fare il tween di un Model?
Direttamente no. Fai il tween di un NumberValue da 0 a 1 e a ogni cambio chiama model:PivotTo(start:Lerp(goal, value)), come nel passo 4.
Come si ferma un tween?
Chiama tween:Cancel() per fermarlo e lasciare la parte dove si trova, oppure tween:Pause() per riprenderlo più tardi con Play().
Fonti e letture
- Roblox Creator Docs: TweenService (in inglese). Create, quali tipi si possono animare e l'annullamento
- Roblox Creator Docs: TweenInfo (in inglese)
- Roblox Creator Docs: Tween (in inglese). Play, Pause, Cancel e Completed
- Roblox Creator Docs: UI animation and tweens (in inglese). stili e direzioni di easing con esempi di UI
- Roblox Creator Docs: PVInstance:PivotTo (in inglese)
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.