ट्यूटोरियल · स्क्रिप्टिंग की बुनियाद

Roblox TweenService: पार्ट को हिलाएँ, घुमाएँ और गायब करें

ट्वीन किसी प्रॉपर्टी को तय समय में मौजूदा मान से लक्ष्य तक धीरे-धीरे बदलता है: प्लेटफ़ॉर्म सरकता है, क्रिस्टल घूमता है, दीवार घुलकर गायब होती है। TweenService बीच के कदम ख़ुद गिनता है, इसलिए आपको ऐसा लूप नहीं लिखना पड़ता जो हर फ़्रेम पार्ट को खिसकाए। इस गाइड में: वे तीन लाइनें जिनके बिना कोई ट्वीन नहीं चलता, TweenInfo की हर सेटिंग क्या करती है, पार्ट को हिलाना, घुमाना और गायब करना, लूप, ट्वीन ख़त्म होने का इंतज़ार, और पूरे मॉडल (Model) को ट्वीन करने की तरकीब।

अपडेट किया गया 20 नवंबर 20266 मिनट में पढ़ेंलेखक:

संक्षेप में

game:GetService("TweenService") से सर्विस लें, TweenInfo.new(time, easingStyle, easingDirection) से हलचल बताएँ, फिर TweenService:Create(part, info, { Position = goal }) कॉल करें और मिले हुए ट्वीन पर :Play() चलाएँ। number, Vector3, CFrame, Color3, UDim2 और ऐसे ही टाइप की कोई भी प्रॉपर्टी ट्वीन की जा सकती है। ख़त्म होने का इंतज़ार करने के लिए tween.Completed:Wait() इस्तेमाल करें, और बिना रुके आगे-पीछे चलाने के लिए TweenInfo में दोहराव की संख्या -1 दें और reverses चालू करें।

  • पार्ट को सर्वर पर ट्वीन करें जब सभी प्लेयर उसे देखें; क्लाइंट पर जब इफ़ेक्ट सिर्फ़ उसी प्लेयर के लिए हो।
  • जिन पार्ट को ट्वीन करते हैं उन्हें Anchored करें, वरना फ़िज़िक्स ट्वीन में दख़ल देगी।
  • Model के पास ट्वीन के लिए Position या CFrame नहीं होता: एक NumberValue ट्वीन करें और मॉडल को PivotTo से हिलाएँ।
इस पेज पर
  1. यह कैसे काम करता है
  2. 1. TweenInfo
  3. 2. घुमाना और गायब होना
  4. 3. लूप
  5. 4. मॉडल
  6. सर्वर या क्लाइंट
  7. Common errors
  8. RoCode के साथ
  9. अक्सर पूछे जाने वाले सवाल
  10. स्रोत और आगे पढ़ें

हर ट्वीन के लिए ज़रूरी तीन लाइनें

Workspace में एक Part डालें, Anchored पर टिक करें, फिर उस पर कर्सर ले जाएँ, + दबाएँ और एक Script डालें। यह स्क्रिप्ट पार्ट को 2 सेकंड में 10 स्टड ऊपर उठाती है:

Script स्थान: Workspace में पार्ट के अंदर नाम: Rise
-- Part के अंदर Script।
local TweenService = game:GetService("TweenService")

local part = script.Parent :: BasePart

local info = TweenInfo.new(2) -- 2 सेकंड, डिफ़ॉल्ट easing
local goal = { Position = part.Position + Vector3.new(0, 10, 0) }

local tween = TweenService:Create(part, info, goal)
tween:Play()

लक्ष्य प्रॉपर्टी के नामों और उन मानों की टेबल है जिन पर उन्हें ख़त्म होना है। कई प्रॉपर्टी एक साथ ट्वीन की जा सकती हैं: { Position = ..., Transparency = 1, Color = Color3.fromRGB(255, 0, 0) }। ट्वीन उन मानों से शुरू होता है जो Play कॉल के समय होते हैं, इसलिए आप हमेशा सिर्फ़ अंत बताते हैं।

क्या ट्वीन हो सकता है और क्या नहीं
टाइपधीरे-धीरे ट्वीन होता है?उदाहरण
numberहाँTransparency, Reflectance, NumberValue का Value
Vector3, CFrameहाँPosition, Size, CFrame, Orientation
Color3हाँColor
UDim2, Vector2हाँGUI का Size और Position
boolean, EnumItemअंत में बदलता हैCanCollide, Material
string, Instanceनहींगलती देता है cannot be tweened due to type mismatch

स्टेप 1: TweenInfo की सारी सेटिंग

TweenInfo.new इस क्रम में छह तक मान लेता है। आख़िरी वाले छोड़े जा सकते हैं।

TweenInfo.new(time, style, direction, repeatCount, reverses, delayTime)
मानडिफ़ॉल्टक्या करता है
time1एक बार चलने के सेकंड।
easingStyleQuadहलचल का आकार: Linear (एक जैसी रफ़्तार), Sine, Quad, Cubic, Back (आगे निकलकर लौटना), Bounce, Elastic, Exponential।
easingDirectionOutOut तेज़ शुरू होकर धीमा होता है; In धीमा शुरू होता है; InOut दोनों करता है।
repeatCount0पहली बार के बाद कितनी बार दोहराना है। -1 हमेशा दोहराता है।
reversesfalseहर बार के बाद शुरुआत पर लौटना।
delayTime0शुरू होने से पहले कितने सेकंड रुकना है।
Script स्थान: Workspace में पार्ट के अंदर नाम: Platform
-- Part के अंदर Platform नाम की Script।
-- हमेशा 12 स्टड आगे-पीछे चलता है, दोनों सिरों पर धीरे से।
local TweenService = game:GetService("TweenService")

local platform = script.Parent :: BasePart

local info = TweenInfo.new(
	3, -- हर दिशा में सेकंड
	Enum.EasingStyle.Sine,
	Enum.EasingDirection.InOut,
	-1, -- हमेशा दोहराएँ
	true -- हर बार वापस लौटें
)

TweenService:Create(platform, info, { Position = platform.Position + Vector3.new(12, 0, 0) }):Play()

अगर प्लेटफ़ॉर्म को उस पर खड़े प्लेयर को साथ ले जाना है, तो ध्यान रखें: ट्वीन वाला anchored पार्ट उनके नीचे से हिलता है, पर उन्हें साथ नहीं ले जाता। यह मामला मूविंग प्लेटफ़ॉर्म गाइड में समझाया गया है।

स्टेप 2: घुमाना, साइज़ और गायब होना

पार्ट घुमाने के लिए CFrame को मौजूदा CFrame गुणा रोटेशन की ओर ट्वीन करें। Orientation का ट्वीन भी काम करता है, लेकिन CFrame से पार्ट अपनी जगह पर घूमता है। यहाँ स्क्रिप्ट चलने पर दीवार घूमती है, फिर घुलकर छोटी होती है, और ट्वीन ख़त्म होने के बाद हट जाती है:

Script स्थान: Workspace में पार्ट के अंदर नाम: FadingWall
-- Part के अंदर FadingWall नाम की Script।
local TweenService = game:GetService("TweenService")

local wall = script.Parent :: BasePart

-- अपनी खड़ी धुरी पर 1 सेकंड में चौथाई चक्कर
local turn = TweenService:Create(wall, TweenInfo.new(1), {
	CFrame = wall.CFrame * CFrame.Angles(0, math.rad(90), 0),
})
turn:Play()
turn.Completed:Wait() -- घूमना ख़त्म होने पर ही आगे बढ़ते हैं

-- फिर एक साथ घोलते और छोटा करते हैं
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 एक PlaybackState के साथ चलता है: Completed, अगर ट्वीन लक्ष्य तक पहुँचा, या Cancelled, अगर उसे tween:Cancel() ने रोका। हमेशा दोहराने वाले ट्वीन पर Completed का इंतज़ार न करें: वह कभी ख़त्म नहीं होगा।

स्टेप 3: तैरती और घूमती चीज़

अलग-अलग प्रॉपर्टी पर दो लूप वाले ट्वीन एक साथ चलते हैं। CFrame से 360 डिग्री के पूरे चक्कर का ट्वीन कुछ नहीं करता, क्योंकि शुरुआत और अंत एक ही रोटेशन हैं, इसलिए रोटेशन एक NumberValue को 0 से 360 तक ट्वीन करता है और उसके हिसाब से CFrame सेट करता है। यह Script एक anchored पार्ट में रखें:

Script स्थान: Workspace में पार्ट के अंदर नाम: FloatingGem
-- Part के अंदर Gem नाम की Script। हमेशा ऊपर-नीचे तैरती और घूमती है।
local TweenService = game:GetService("TweenService")

local FLOAT_HEIGHT = 1.5 -- जहाँ आपने रखा उससे इतने स्टड ऊपर
local FLOAT_SECONDS = 1.2 -- हर दिशा में
local SPIN_SECONDS = 3 -- एक पूरा चक्कर

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()

रोटेशन Linear easing इस्तेमाल करता है, इसलिए एक जैसी रफ़्तार से घूमता है, और हर चक्र फिर 0 से शुरू होता है, जो 360 वाला ही कोण है, इसलिए झटका नहीं लगता। कॉइन कलेक्ट गाइड ऐसी चीज़ों को गेम में जोड़ती है।

स्टेप 4: पूरे मॉडल का ट्वीन

Model के पास Position या CFrame प्रॉपर्टी नहीं होती, इसलिए TweenService:Create(model, ...) के पास हिलाने को कुछ नहीं है। इसकी जगह एक NumberValue को 0 से 1 तक ट्वीन करें और मॉडल को PivotTo से हिलाएँ, जो उसके अंदर के सभी पार्ट एक साथ ले जाता है:

Script स्थान: Workspace में मॉडल के अंदर नाम: Elevator
-- Model के अंदर Elevator नाम की Script।
-- पूरे मॉडल को 20 स्टड ऊपर और वापस ले जाती है, सभी पार्ट एक साथ।
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()

मॉडल के सभी पार्ट Anchored करें। TweenInfo के अंत में 2 हर बार चलने से पहले की देरी है, इसलिए लिफ़्ट ऊपर और नीचे रुकती है। दरवाज़ों वाली गाइड इसी तरीके से कई पार्ट वाले दरवाज़े खोलती है।

सर्वर या क्लाइंट?

सर्वर Script में चलाया गया ट्वीन सर्वर पर पार्ट बदलता है, और नए मान सभी प्लेयर तक replicate होते हैं, इसलिए सब उसे देखते हैं। LocalScript का ट्वीन पार्ट को सिर्फ़ उस प्लेयर की स्क्रीन पर बदलता है।

ट्वीन कहाँ चलाएँ
कहाँ चलाएँकबउदाहरण
सर्वर Scriptबदलाव गेम के लिए या सबके लिए ज़रूरी है।दरवाज़े, हिलती रुकावटें, खुलता पुल
LocalScriptसिर्फ़ इसी प्लेयर को देखना है, या यह सिर्फ़ विज़ुअल इफ़ेक्ट है।उठाने वाले प्लेयर के लिए घुलकर गायब होती चीज़, UI

Replication सेकंड में कई बार अपडेट भेजता है, इसलिए ज़्यादातर प्लेयर को सर्वर ट्वीन स्मूद लगते हैं, लेकिन बहुत तेज़ या बहुत सारे सर्वर ट्वीन धीमे कनेक्शन पर कम स्मूद दिख सकते हैं। बहुत सारी सजावटी हलचल (सैकड़ों घूमते कॉइन) के लिए ट्वीन हर क्लाइंट पर LocalScript में चलाएँ।

आम गलतियाँ और उनके हल

Play दबाने से पहले Output विंडो खोलें (Window मेनू, फिर Output)।

पार्ट बिल्कुल नहीं हिलता

जाँचें कि आपने ट्वीन पर :Play() कॉल किया, कि लक्ष्य में प्रॉपर्टी का नाम ठीक लिखा है (Position, position नहीं) और कि यह Script ऐसी जगह है जहाँ स्क्रिप्ट चलती हैं (Workspace में पार्ट के अंदर या ServerScriptService में)।

ट्वीन के दौरान पार्ट गिरता या काँपता है

वह anchored नहीं है, इसलिए गुरुत्वाकर्षण और टक्कर ट्वीन में दख़ल देते हैं। Anchored पर टिक करें।

TweenService:Create property cannot be tweened due to type mismatch

लक्ष्य का मान गलत टाइप का है, जैसे Vector3 टाइप की प्रॉपर्टी के लिए नंबर। गलती वाला पेज (अंग्रेज़ी में) देखें।

Unable to cast to Dictionary या Unable to cast value to Object

आर्ग्युमेंट गलत क्रम में या गलत टाइप के हैं। क्रम हमेशा Create(instance, tweenInfo, goalTable) है। Unable to cast value to Object (अंग्रेज़ी में) देखें।

RoCode से बनाएँ

अगर आप ट्वीन हाथ से नहीं लिखना चाहते, तो RoCode उन्हें आपके खुले place में बना सकता है। RoCode, Roblox Studio के लिए एक स्वतंत्र AI एजेंट है, Roblox का नहीं: आप वेब चैट में बदलाव बताते हैं, और उसका Studio प्लगइन आपके Explorer में स्क्रिप्ट बनाता है, इसलिए कोड पेस्ट करने की ज़रूरत नहीं।

आप लिखते हैं

राउंड शुरू होने पर Workspace में पुल वाला मॉडल 15 स्टड बगल में खिसके, NumberValue ट्वीन और PivotTo से, और साथ ही लाल बैरियर पार्ट 1 सेकंड में घुलकर गायब हों।

RoCode करता है
  • कुछ भी लिखने से पहले Search Game से सही पार्ट और मॉडल ढूँढ सकता है
  • Create Script से Script लिखता है, और उसे Check Script से कंपाइल जाँचने को कहा गया है
  • बदलावों के हर बैच से पहले और बाद में undo पॉइंट रखता है, इसलिए Ctrl+Z एक बार में एक बैच वापस करता है

प्लगइन 3.9 या नए के साथ RoCode एक छोटा playtest चलाकर गलतियाँ पढ़ सकता है, लेकिन हलचल को अपनी आँखों से परखना सबसे आसान है, इसलिए Play दबाकर देखें। RoCode, Studio से कैसे जुड़ता है।

अक्सर पूछे जाने वाले सवाल

Roblox में TweenService कैसे इस्तेमाल करें?

सर्विस लें, TweenInfo बनाएँ, TweenService:Create(object, info, { Property = goal }) कॉल करें और नतीजे पर :Play() चलाएँ। पहले सेक्शन में तीन लाइन का उदाहरण है।

ट्वीन को हमेशा के लिए लूप कैसे करें?

TweenInfo.new में चौथे मान (repeatCount) के रूप में -1 दें, और अगर आगे-पीछे चलना है तो पाँचवें के रूप में true।

ट्वीन ख़त्म होने का इंतज़ार कैसे करें?

tween:Play() के बाद tween.Completed:Wait() कॉल करें या tween.Completed से एक फ़ंक्शन जोड़ें।

क्या Model को ट्वीन किया जा सकता है?

सीधे नहीं। एक NumberValue को 0 से 1 तक ट्वीन करें और हर बदलाव पर model:PivotTo(start:Lerp(goal, value)) कॉल करें, जैसे स्टेप 4 में।

ट्वीन कैसे रोकें?

उसे रोककर पार्ट को वहीं छोड़ने के लिए tween:Cancel() कॉल करें, या tween:Pause(), ताकि बाद में Play() से आगे चला सकें।

स्रोत और आगे पढ़ें

कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।

अपने गेम में RoCode आज़माएँ।

हर दिन मुफ़्त क्रेडिट, कार्ड की ज़रूरत नहीं। प्लगइन इंस्टॉल करें, फ़ीचर बताएँ और देखें कि Studio में क्या बना।