Pe scurt
Obține serviciul prin game:GetService("TweenService"), descrie mișcarea prin TweenInfo.new(time, easingStyle, easingDirection), apoi apelează TweenService:Create(part, info, { Position = goal }) și pornește :Play() pe tween-ul obținut. Poți face tween pe orice proprietate de tip number, Vector3, CFrame, Color3, UDim2 și altele asemănătoare. Ca să aștepți finalul, folosește tween.Completed:Wait(), iar pentru o mișcare dus-întors fără sfârșit setează în TweenInfo numărul de repetări -1 și pornește reverses.
- Fă tween pe un part pe server când trebuie să-l vadă toți jucătorii; pe client când efectul e necesar doar acelui jucător.
- Ancorează (Anchored) parts-urile pe care faci tween, altfel fizica va încurca tween-ul.
- Un Model nu are Position sau CFrame pentru tween: fă tween pe un NumberValue și mută modelul prin
PivotTo.
Pe această pagină
Cele trei linii de care are nevoie orice tween
Inserează un Part în Workspace, bifează Anchored, apoi treci cu mouse-ul peste el, apasă + și inserează un Script. Acest script ridică part-ul cu 10 studs în 2 secunde:
-- Script în interiorul unui Part.
local TweenService = game:GetService("TweenService")
local part = script.Parent :: BasePart
local info = TweenInfo.new(2) -- 2 secunde, easing implicit
local goal = { Position = part.Position + Vector3.new(0, 10, 0) }
local tween = TweenService:Create(part, info, goal)
tween:Play()
Ținta este un tabel cu nume de proprietăți și valorile la care trebuie să ajungă. Poți face tween pe mai multe proprietăți deodată: { Position = ..., Transparency = 1, Color = Color3.fromRGB(255, 0, 0) }. Tween-ul pornește de la valorile existente în momentul apelului Play, așa că setezi mereu doar finalul.
| Tip | Tween lin? | Exemple |
|---|---|---|
| number | Da | Transparency, Reflectance, Value la NumberValue |
| Vector3, CFrame | Da | Position, Size, CFrame, Orientation |
| Color3 | Da | Color |
| UDim2, Vector2 | Da | Size și Position la GUI |
| boolean, EnumItem | Se comută la final | CanCollide, Material |
| string, Instance | Nu | Dă eroarea cannot be tweened due to type mismatch |
Pasul 1: toate setările TweenInfo
TweenInfo.new primește până la șase valori, în această ordine. Ultimele pot lipsi.
| Valoare | Implicit | Ce face |
|---|---|---|
time | 1 | Secunde pentru o redare. |
easingStyle | Quad | Forma mișcării: Linear (viteză constantă), Sine, Quad, Cubic, Back (cu depășire), Bounce, Elastic, Exponential. |
easingDirection | Out | Out pornește repede și încetinește; In pornește încet; InOut le face pe amândouă. |
repeatCount | 0 | De câte ori se repetă după prima redare. -1 repetă la nesfârșit. |
reverses | false | Revine la început după fiecare redare. |
delayTime | 0 | Câte secunde așteaptă înainte de pornire. |
-- Script în interiorul unui Part numit Platform.
-- Merge la nesfârșit dus-întors 12 studs, lin la ambele capete.
local TweenService = game:GetService("TweenService")
local platform = script.Parent :: BasePart
local info = TweenInfo.new(
3, -- secunde în fiecare sens
Enum.EasingStyle.Sine,
Enum.EasingDirection.InOut,
-1, -- repetă la nesfârșit
true -- revine de fiecare dată
)
TweenService:Create(platform, info, { Position = platform.Position + Vector3.new(12, 0, 0) }):Play()
Dacă platforma trebuie să-i care pe jucătorii care stau pe ea, ține cont: un part ancorat cu tween se mișcă sub ei, dar nu-i duce cu el. Acest caz e tratat în ghidul de platformă mobilă.
Pasul 2: rotire, mărime și dispariție
Ca să rotești un part, fă tween pe CFrame spre CFrame-ul curent înmulțit cu o rotație. Un tween pe Orientation merge și el, dar cu CFrame part-ul se rotește pe loc. Aici peretele, la pornirea scriptului, se rotește, apoi se dizolvă și se micșorează, iar după finalul tween-ului e șters:
-- Script în interiorul unui Part numit FadingWall.
local TweenService = game:GetService("TweenService")
local wall = script.Parent :: BasePart
-- rotire cu un sfert de tură în jurul axei verticale proprii, în 1 secundă
local turn = TweenService:Create(wall, TweenInfo.new(1), {
CFrame = wall.CFrame * CFrame.Angles(0, math.rad(90), 0),
})
turn:Play()
turn.Completed:Wait() -- continuăm doar când rotirea s-a terminat
-- apoi dizolvăm și micșorăm în același timp
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 se declanșează cu un PlaybackState: Completed, dacă tween-ul a ajuns la țintă, sau Cancelled, dacă l-a oprit tween:Cancel(). Nu aștepta Completed la un tween care se repetă la nesfârșit: nu se va termina niciodată.
Pasul 3: un obiect care plutește și se rotește
Două tween-uri în buclă pe proprietăți diferite rulează în același timp. Un tween de o tură completă de 360 de grade prin CFrame nu face nimic, pentru că începutul și finalul sunt aceeași rotație, așa că rotirea face tween pe un NumberValue de la 0 la 360 și setează CFrame-ul după el. Pune acest Script într-un part ancorat:
-- Script în interiorul unui Part numit Gem. Plutește la nesfârșit în sus și în jos și se rotește.
local TweenService = game:GetService("TweenService")
local FLOAT_HEIGHT = 1.5 -- studs mai sus de locul unde l-ați pus
local FLOAT_SECONDS = 1.2 -- în fiecare sens
local SPIN_SECONDS = 3 -- o tură completă
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()
Rotirea folosește easing Linear, așa că se învârte cu viteză constantă, iar fiecare ciclu începe din nou de la 0, care e același unghi ca 360, deci nu există smucitură. Ghidul de colectare a monedelor integrează astfel de obiecte în joc.
Pasul 4: tween pe un model întreg
Un Model nu are proprietatea Position sau CFrame, așa că TweenService:Create(model, ...) nu are ce muta. În schimb, fă tween pe un NumberValue de la 0 la 1 și mută modelul prin PivotTo, care mută toate parts-urile din el împreună:
-- Script în interiorul unui Model numit Elevator.
-- Mută tot modelul 20 de studs în sus și înapoi, toate parts-urile împreună.
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()
Ancorează toate parts-urile modelului. Doiul de la finalul TweenInfo este întârzierea dinaintea fiecărei redări, așa că liftul stă sus și jos. Ghidul de uși deschide în același fel uși din mai multe parts.
Server sau client?
Un tween pornit într-un Script de server schimbă part-ul pe server, iar valorile noi se replică la toți jucătorii, așa că îl văd toți. Un tween într-un LocalScript schimbă part-ul doar pe ecranul acelui jucător.
| Pornește-l în | Când | Exemplu |
|---|---|---|
| Script de server | Schimbarea contează pentru joc sau pentru toți. | Uși, obstacole mobile, un pod care se desface |
| LocalScript | Trebuie să vadă doar acest jucător sau e un efect pur vizual. | Un obiect care se dizolvă la jucătorul care l-a luat, UI |
Replicarea trimite actualizări de multe ori pe secundă, așa că tween-urile de pe server par line pentru majoritatea jucătorilor, dar tween-urile foarte rapide sau foarte numeroase de pe server pot arăta mai puțin lin pe o conexiune lentă. Pentru multă mișcare decorativă (sute de monede care se rotesc), pornește tween-urile într-un LocalScript pe fiecare client.
Erori frecvente și soluții
Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play.
Part-ul nu se mișcă deloc
Verifică faptul că ai apelat :Play() pe tween, că numele proprietății din țintă e scris exact (Position, nu position) și că e un Script într-un loc unde scripturile rulează (într-un part din Workspace sau în ServerScriptService).
Part-ul cade sau tremură în timpul tween-ului
Nu e ancorat, așa că gravitația și coliziunile încurcă tween-ul. Bifează Anchored.
TweenService:Create property cannot be tweened due to type mismatch
Valoarea țintă e de alt tip, de exemplu un număr pentru o proprietate de tip Vector3. Vezi pagina erorii (în engleză).
Unable to cast to Dictionary sau Unable to cast value to Object
Argumentele nu sunt în ordinea corectă sau nu sunt de tipul corect. Ordinea e mereu Create(instance, tweenInfo, goalTable). Vezi Unable to cast value to Object (în engleză).
Fă-l cu RoCode
Dacă nu ai chef să scrii tween-urile de mână, RoCode le poate construi în place-ul pe care îl ai deschis. RoCode este un agent AI independent pentru Roblox Studio, nu de la Roblox: descrii schimbarea în chatul web, iar pluginul lui pentru Studio creează scripturile în Explorer-ul tău, așa că nu trebuie să lipești cod.
Fă ca modelul de pod din Workspace să alunece 15 studs într-o parte când începe runda, printr-un tween pe un NumberValue și PivotTo, și în același timp dizolvă parts-urile roșii de barieră în 1 secundă.
- Poate găsi parts-urile și modelele potrivite prin Search Game înainte să scrie ceva
- Scrie Script-ul prin Create Script și are instrucțiunea să verifice compilarea prin Check Script
- Pune un punct de undo înainte și după fiecare pachet de schimbări, așa că Ctrl+Z anulează câte un pachet
Cu pluginul 3.9 sau mai nou RoCode poate porni un playtest scurt și poate citi erorile, dar mișcarea e cel mai ușor de judecat cu ochii tăi, așa că apasă Play și uită-te. Cum se conectează RoCode la Studio.
Întrebări frecvente
Cum folosesc TweenService în Roblox?
Obține serviciul, creează un TweenInfo, apelează TweenService:Create(object, info, { Property = goal }) și pornește :Play() pe rezultat. Prima secțiune are un exemplu de trei linii.
Cum fac un tween să se repete la nesfârșit?
Dă -1 ca a patra valoare în TweenInfo.new (repeatCount) și true ca a cincea, dacă trebuie să meargă dus-întors.
Cum aștept terminarea unui tween?
Apelează tween.Completed:Wait() după tween:Play() sau conectează o funcție la tween.Completed.
Pot face tween pe un Model?
Direct, nu. Fă tween pe un NumberValue de la 0 la 1 și la fiecare schimbare apelează model:PivotTo(start:Lerp(goal, value)), ca la pasul 4.
Cum opresc un tween?
Apelează tween:Cancel() ca să-l oprești și să lași part-ul unde e, sau tween:Pause() ca să continui apoi prin Play().
Surse și lecturi suplimentare
- Roblox Creator Docs: TweenService (în engleză). Create, ce tipuri suportă tween și anularea
- Roblox Creator Docs: TweenInfo (în engleză)
- Roblox Creator Docs: Tween (în engleză). Play, Pause, Cancel și Completed
- Roblox Creator Docs: UI animation and tweens (în engleză). stiluri și direcții de easing pe exemplul UI
- Roblox Creator Docs: PVInstance:PivotTo (în engleză)
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.