Kurz gesagt
Hol dir den Service mit game:GetService("TweenService"), beschreib die Bewegung mit TweenInfo.new(time, easingStyle, easingDirection), ruf dann TweenService:Create(part, info, { Position = goal }) auf und starte den zurückgegebenen Tween mit :Play(). Jede Eigenschaft vom Typ number, Vector3, CFrame, Color3, UDim2 oder Ähnlichem lässt sich tweenen. Mit tween.Completed:Wait() wartest du auf das Ende, und für eine Hin-und-her-Schleife gibst du TweenInfo eine Wiederholungszahl von -1 und schaltest reverses ein.
- Tweene den Part auf dem Server, wenn jeder Spieler es sehen soll; auf dem Client für Effekte, die nur dieser Spieler braucht.
- Verankere Parts, die du tweenst, sonst kämpft die Physik gegen den Tween.
- Ein Model hat keine Position oder CFrame zum Tweenen: Tweene einen NumberValue und bewege das Model mit
PivotTo.
Auf dieser Seite
Die drei Zeilen, die jeder Tween braucht
Füge einen Part in Workspace ein, hak Anchored an, fahr dann mit der Maus darüber, klick auf + und füge ein Script ein. Dieses bewegt den Part in 2 Sekunden 10 Studs nach oben:
-- Script in einem Part.
local TweenService = game:GetService("TweenService")
local part = script.Parent :: BasePart
local info = TweenInfo.new(2) -- 2 Sekunden, Standard-Easing
local goal = { Position = part.Position + Vector3.new(0, 10, 0) }
local tween = TweenService:Create(part, info, goal)
tween:Play()
Das Ziel ist eine Tabelle aus Eigenschaftsnamen und den Werten, bei denen sie enden sollen. Du kannst mehrere Eigenschaften gleichzeitig tweenen: { Position = ..., Transparency = 1, Color = Color3.fromRGB(255, 0, 0) }. Der Tween startet bei den Werten, die beim Aufruf von Play gelten, also gibst du immer nur das Ende an.
| Typ | Fließender Tween? | Beispiele |
|---|---|---|
| number | Ja | Transparency, Reflectance, der Value eines NumberValue |
| Vector3, CFrame | Ja | Position, Size, CFrame, Orientation |
| Color3 | Ja | Color |
| UDim2, Vector2 | Ja | Size und Position von GUIs |
| boolean, EnumItem | Springt am Ende um | CanCollide, Material |
| string, Instance | Nein | Ergibt cannot be tweened due to type mismatch (auf Englisch) |
Schritt 1: Jede Einstellung von TweenInfo
TweenInfo.new nimmt bis zu sechs Werte, in dieser Reihenfolge. Die am Ende kannst du weglassen.
| Wert | Standard | Was er macht |
|---|---|---|
time | 1 | Sekunden für einen Durchlauf. |
easingStyle | Quad | Die Form der Bewegung: Linear (gleichmäßiges Tempo), Sine, Quad, Cubic, Back (schießt über das Ziel hinaus), Bounce, Elastic, Exponential. |
easingDirection | Out | Out startet schnell und bremst ab; In startet langsam; InOut macht beides. |
repeatCount | 0 | Zusätzliche Durchläufe nach dem ersten. -1 wiederholt für immer. |
reverses | false | Nach jedem Durchlauf zurück zum Anfang spielen. |
delayTime | 0 | Sekunden Wartezeit vor dem Start. |
-- Script in einem Part namens Platform.
-- Gleitet für immer 12 Studs hin und her, mit sanftem Abbremsen an beiden Enden.
local TweenService = game:GetService("TweenService")
local platform = script.Parent :: BasePart
local info = TweenInfo.new(
3, -- Sekunden pro Richtung
Enum.EasingStyle.Sine,
Enum.EasingDirection.InOut,
-1, -- für immer wiederholen
true -- jedes Mal zurückkommen
)
TweenService:Create(platform, info, { Position = platform.Position + Vector3.new(12, 0, 0) }):Play()
Soll eine Plattform Spieler mitnehmen, die darauf stehen: Ein getweenter, verankerter Part bewegt sich unter ihnen weg, nimmt sie aber nicht mit. Der Guide zu beweglichen Plattformen (auf Englisch) behandelt diesen Fall.
Schritt 2: Drehen, skalieren und ausblenden
Zum Drehen tweenst du CFrame zur aktuellen CFrame mal einer Drehung. Orientation zu tweenen geht auch, aber mit CFrame bleibt der Part beim Drehen an seinem Platz. Hier dreht sich eine Wand, wenn das Skript läuft, verblasst und schrumpft dann und wird entfernt, sobald der Tween fertig ist:
-- Script in einem Part namens FadingWall.
local TweenService = game:GetService("TweenService")
local wall = script.Parent :: BasePart
-- in 1 Sekunde eine Vierteldrehung um die eigene Hochachse des Parts
local turn = TweenService:Create(wall, TweenInfo.new(1), {
CFrame = wall.CFrame * CFrame.Angles(0, math.rad(90), 0),
})
turn:Play()
turn.Completed:Wait() -- erst weitermachen, wenn er fertig ist
-- dann gleichzeitig ausblenden und schrumpfen
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 feuert mit einem PlaybackState: Completed, wenn er das Ziel erreicht hat, oder Cancelled, wenn tween:Cancel() ihn gestoppt hat. Warte bei einem Tween, der sich für immer wiederholt, nicht auf Completed: Er wird nie fertig.
Schritt 3: Ein schwebendes, drehendes Pickup
Zwei Tween-Schleifen auf verschiedenen Eigenschaften laufen nebeneinander. Volle 360 Grad mit CFrame zu tweenen bewirkt nichts, weil Start und Ende dieselbe Drehung sind, also tweent die Drehung einen NumberValue von 0 bis 360 und setzt die CFrame daraus. Leg dieses Script in einen verankerten Part:
-- Script in einem Part namens Gem. Schwebt für immer auf und ab und dreht sich.
local TweenService = game:GetService("TweenService")
local FLOAT_HEIGHT = 1.5 -- Studs über der Stelle, an der du ihn platziert hast
local FLOAT_SECONDS = 1.2 -- pro Richtung
local SPIN_SECONDS = 3 -- eine volle Drehung
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()
Die Drehung nutzt Linear-Easing, damit sie gleichmäßig schnell läuft, und sie beginnt bei jeder Schleife wieder bei 0, was derselbe Winkel wie 360 ist, also gibt es keinen Sprung. Der Guide zum Coins-Sammeln (auf Englisch) baut solche Pickups in ein Spiel ein.
Schritt 4: Ein ganzes Model tweenen
Ein Model hat keine Eigenschaft Position oder CFrame, also hat TweenService:Create(model, ...) nichts zu bewegen. Tweene stattdessen einen NumberValue von 0 bis 1 und bewege das Model mit PivotTo, das jeden Part darin gemeinsam bewegt:
-- Script in einem Model namens Elevator.
-- Bewegt das ganze Model 20 Studs nach oben und zurück, alle Parts gemeinsam.
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()
Verankere jeden Part des Models. Die 2 am Ende von TweenInfo ist die Verzögerung vor jedem Durchlauf, also wartet der Aufzug oben und unten. Der Tür-Guide (auf Englisch) nutzt dasselbe Muster, um Türen aus mehreren Parts aufschwingen zu lassen.
Server oder Client?
Ein Tween, der in einem Server-Script läuft, ändert den Part auf dem Server, und die neuen Werte werden an jeden Spieler repliziert, also sehen ihn alle. Ein Tween in einem LocalScript ändert den Part nur auf dem Bildschirm dieses Spielers.
| Abspielen in | Wann | Beispiel |
|---|---|---|
| Einem Server-Script | Die Änderung ist wichtig für das Spiel oder für alle. | Türen, bewegliche Hindernisse, eine Brücke, die sich öffnet |
| Einem LocalScript | Nur dieser Spieler soll es sehen, oder es ist ein reiner Grafikeffekt. | Ein Pickup, das für den Spieler verblasst, der es eingesammelt hat, UI |
Die Replikation schickt viele Male pro Sekunde Updates, also sehen Server-Tweens für die meisten Spieler flüssig aus, aber sehr schnelle oder sehr viele Server-Tweens können bei langsamen Verbindungen weniger flüssig wirken. Für viel dekorative Bewegung (Hunderte drehende Coins) spiel die Tweens in einem LocalScript auf jedem Client ab.
Häufige Fehler und Lösungen
Öffne das Output-Fenster (Menü Window, dann Output), bevor du auf Play drückst.
Der Part bewegt sich gar nicht
Prüf, ob du :Play() auf dem Tween aufgerufen hast, ob der Name der Zieleigenschaft genau stimmt (Position, nicht position) und ob es ein Script an einem Ort ist, an dem Skripte laufen (in einem Part in Workspace oder in ServerScriptService).
Der Part fällt oder wackelt beim Tweenen
Er ist nicht verankert, also kämpfen Schwerkraft und Kollisionen gegen den Tween. Hak Anchored an.
TweenService:Create property cannot be tweened due to type mismatch
Der Zielwert hat den falschen Typ, zum Beispiel eine Zahl für eine Vector3-Eigenschaft. Siehe die Fehlerseite (auf Englisch).
Unable to cast to Dictionary oder Unable to cast value to Object
Die Argumente stehen in der falschen Reihenfolge oder haben den falschen Typ. Es heißt immer Create(instance, tweenInfo, goalTable). Siehe Unable to cast value to Object (auf Englisch).
Mit RoCode bauen
Wenn du Tweens nicht von Hand schreiben willst, kann RoCode sie in dem Spiel bauen, das du offen hast. RoCode ist ein unabhängiger KI-Agent für Roblox Studio und stammt nicht von Roblox: Du beschreibst die Änderung in einem Webchat, und sein Studio-Plugin erstellt die Skripte in deinem Explorer, also gibt es keinen Code zum Einfügen. Prompts kannst du auf Deutsch schreiben.
Lass das Brücken-Model in Workspace beim Rundenstart 15 Studs zur Seite gleiten, mit einem NumberValue-Tween und PivotTo, und blende gleichzeitig die roten Barriere-Parts in 1 Sekunde aus.
- Kann mit Search Game die Parts und Models finden, die du meinst, bevor es etwas schreibt
- Schreibt das Script mit Create Script und ist angewiesen, es mit Check Script auf Kompilierfehler zu prüfen
- Setzt vor und nach jeder Änderungsrunde einen Undo-Punkt, sodass Strg+Z jeweils eine Runde zurückgeht
Mit Plugin 3.9 oder neuer kann RoCode einen kurzen Playtest machen und die Fehler lesen, aber Bewegung beurteilst du am besten mit eigenen Augen, also drück auf Play und schau zu. Wie sich RoCode mit Studio verbindet.
Häufige Fragen
Wie nutze ich TweenService in Roblox?
Hol dir den Service, erstelle ein TweenInfo, ruf TweenService:Create(object, info, { Property = goal }) auf und starte das Ergebnis mit :Play(). Der erste Abschnitt hat ein Beispiel mit drei Zeilen.
Wie lasse ich einen Tween für immer wiederholen?
Gib -1 als vierten Wert von TweenInfo.new an (repeatCount), und true als fünften, wenn er hin und her laufen soll.
Wie warte ich, bis ein Tween fertig ist?
Ruf nach tween:Play() einfach tween.Completed:Wait() auf, oder verbinde eine Funktion mit tween.Completed.
Kann ich ein Model tweenen?
Nicht direkt. Tweene einen NumberValue von 0 bis 1 und ruf bei jeder Änderung model:PivotTo(start:Lerp(goal, value)) auf, wie in Schritt 4.
Wie stoppe ich einen Tween?
Ruf tween:Cancel() auf, um ihn zu stoppen und den Part an seiner Stelle zu lassen, oder tween:Pause(), um später mit Play() weiterzumachen.
Quellen und weiterführende Links
- Roblox Creator Docs: TweenService (auf Englisch). Create, tweenbare Typen und Abbrechen
- Roblox Creator Docs: TweenInfo (auf Englisch)
- Roblox Creator Docs: Tween (auf Englisch). Play, Pause, Cancel und Completed
- Roblox Creator Docs: UI animation and tweens (auf Englisch). Easing-Stile und Richtungen, an UI gezeigt
- Roblox Creator Docs: PVInstance:PivotTo (auf Englisch)
So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 12. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.