ट्यूटोरियल · गेम सिस्टम

Roblox Studio में कटसीन कैसे बनाएं

Roblox में कटसीन एक कैमरा है जो कुछ सेकंड के लिए नियंत्रण ले लेता है: शॉट के बीच कट करता है या धीरे-धीरे उड़ता है, कैप्शन दिखाता है और नियंत्रण प्लेयर को लौटा देता है। इस गाइड में हम ऐसी कटसीन बनाते हैं जिसे आप वहाँ अदृश्य पार्ट रखकर सेट करते हैं जहाँ कैमरा होना चाहिए, बिना प्लगइन के। सर्वर तय करता है कि प्लेयर उसे कब देखे (पहले स्पॉन पर या ट्रिगर छूने पर), और प्लेयर का डिवाइस कैमरा चलाता है, काली पट्टियाँ और Skip बटन दिखाता है और कैमरा लौटाता है।

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

संक्षेप में

Workspace.Cutscenes के अंदर एक फ़ोल्डर में 1, 2, 3 नाम के अदृश्य Anchored पार्ट रखें, हर एक का मुँह उस ओर जहाँ कैमरा देखे। ServerScriptService की Script उनके CFrame पढ़ती है, प्लेयर को अपनी जगह रोकती है और शॉट RemoteEvent से उस प्लेयर को भेजती है। StarterPlayerScripts का LocalScript workspace.CurrentCamera.CameraType को Scriptable करता है, हर फ़्रेम कैमरा एक शॉट से दूसरे तक ले जाता है (TweenService:GetValue से स्मूथ करके), और फिर CameraType को वापस Custom और CameraSubject को प्लेयर के Humanoid पर कर देता है।

  • कैमरे को सिर्फ़ प्लेयर का डिवाइस चला सकता है, इसलिए कैमरा कोड LocalScript है। सर्वर सिर्फ़ तय करता है कि कौन कौन सी कटसीन कब देखे।
  • कैमरा Scriptable होने पर Roblox Camera.Focus अपडेट करना बंद कर देता है। रेफ़रेंस में Focus को हर फ़्रेम अपडेट करने को कहा गया है, वरना पुराने फ़ोकस से दूर की डायनैमिक लाइटिंग शायद न बने।
  • Camera:Interpolate deprecated है। Roblox के रेफ़रेंस में कैमरा को TweenService से ऐनिमेट करने को कहा गया है।
इस पेज पर
  1. यह कैसे काम करता है
  2. 1. शॉट
  3. 2. सर्वर स्क्रिप्ट
  4. 3. LocalScript
  5. 4. ट्रिगर
  6. कैमरे की बारीकियाँ
  7. पुराने ट्यूटोरियल
  8. चीट से बचाव
  9. 5. जाँच
  10. आगे बढ़ाना
  11. Common errors
  12. RoCode के साथ
  13. अक्सर पूछे जाने वाले सवाल
  14. स्रोत और आगे पढ़ें

कटसीन कैसे काम करती है

चित्रणअसली रफ़्तार में दो शॉट का इंट्रो: पहले शॉट पर कट, 1 सेकंड रुकना, 2.5 सेकंड में पुल तक उड़ान, 1 सेकंड रुकना, फिर कैमरा प्लेयर पर लौटता है।

हर प्लेयर के डिवाइस का अपना Camera ऑब्जेक्ट होता है, workspace.CurrentCamera में, इसलिए प्लेयर जो देखता है उसे सिर्फ़ LocalScript हिला सकता है। कौन कौन सी कटसीन कब देखे, यह तय करना सर्वर का काम है। गाइड काम को ठीक ऐसे ही बाँटती है। एक कटसीन ऐसे चलती है:

  1. सर्वर तय करता है कि प्लेयर को कटसीन देखनी चाहिए: सर्वर पर पहले स्पॉन पर Intro, या ट्रिगर पार्ट छूने पर कोई दूसरी।
  2. CutsceneService शॉट पार्ट के CFrame और सेटिंग पढ़ती है, Roblox से उस प्लेयर के लिए पहले शॉट का इलाका लोड करने को कहती है, प्लेयर का HumanoidRootPart Anchored करती है ताकि वह अपनी जगह खड़ा रहे, और id और शॉट की सूची के साथ CutsceneEvent सिर्फ़ उसी प्लेयर को भेजती है।
  3. प्लेयर के डिवाइस पर CutscenePlayer काली पट्टियाँ और Skip बटन दिखाता है, प्लेयर लिस्ट, बैकपैक, हेल्थ बार और टच कंट्रोल छिपाता है, कैमरा Scriptable करता है और हर फ़्रेम उसे हिलाता है।
  4. जब आख़िरी शॉट ख़त्म होता है या प्लेयर Skip दबाता है, तो वह कैमरा कैरेक्टर को लौटाता है और उसी id के साथ सर्वर को CutsceneEvent भेजता है।
  5. सर्वर प्लेयर से Anchored हटाता है। अगर यह संदेश कभी नहीं आया, तो भी वह कटसीन की लंबाई और 2 सेकंड बीतने पर Anchored हटा देता है। टाइमर तब शुरू होता है जब सर्वर कटसीन भेजता है, और धीमे जॉइन पर डिवाइस इंट्रो कुछ सेकंड देर से शुरू कर सकता है, क्योंकि ReplicatedFirst के बाहर का LocalScript गेम लोड होने तक नहीं चलता। तब प्लेयर इंट्रो उसकी स्क्रीन पर ख़त्म होने से पहले फिर से हिल सकता है।
कटसीन सिस्टम किन चीज़ों से बनता है
हिस्साकहाँ होता हैक्या करता है
Script CutsceneServiceServerScriptServiceतय करती है कि कौन कौन सी कटसीन कब देखे, शॉट पढ़ती है, प्लेयर को अपनी जगह रोकती है और याद रखती है कि किसने क्या पहले देख लिया।
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsप्लेयर की स्क्रीन पर कटसीन चलाता है: पट्टियाँ, कैप्शन, Skip और कैमरे की हलचल। आख़िर में कैमरा लौटाता है।
RemoteEvent CutsceneEventReplicatedStorage (इसे CutsceneService बनाती है)सर्वर से एक प्लेयर तक शॉट, और वापस "कटसीन ख़त्म हुई" संदेश ले जाता है।
Folder CutscenesWorkspaceहर कटसीन का एक फ़ोल्डर, जैसे Intro, जिसमें 1, 2, 3 शॉट पार्ट हैं।
Folder CutsceneTriggersWorkspace (ज़रूरी नहीं)पार्ट जो प्लेयर के छूने पर कटसीन शुरू करते हैं।
कटसीन सिस्टम तैयार होने पर Explorer। Bridge और CutsceneTriggers फ़ोल्डर स्टेप 4 में आते हैं। गेम शुरू होने पर CutsceneService, ReplicatedStorage में CutsceneEvent नाम का RemoteEvent जोड़ती है।
Workspace
  Cutscenes Folder new
    Intro Folder new
      1 Part new
      2 Part new
      3 Part new
    Bridge Folder new
      1 Part new
      2 Part new
  CutsceneTriggers Folder new
    BridgeTrigger Part new
ServerScriptService
  CutsceneService Script new
StarterPlayer
  StarterPlayerScripts
    CutscenePlayer LocalScript new

स्टेप 1: कैमरा शॉट रखें

हर शॉट एक अदृश्य पार्ट है। कैमरा पार्ट की पोज़िशन लेता है और उसी ओर देखता है जिधर उसका आगे का हिस्सा है, यानी शॉट रखना कैमरा रखना है।

  1. Explorer में Workspace पर कर्सर ले जाएँ, + बटन दबाएँ और Cutscenes नाम का Folder डालें। उसके अंदर Intro नाम का Folder डालें। नामों में अक्षरों का केस मायने रखता है।
  2. Studio का कैमरा पहले चाहे गए दृश्य पर ले जाएँ, जैसे फ़ोटो का फ़्रेम बना रहे हों।
  3. Intro में एक Part डालें और उसका नाम 1 रखें।
  4. Command Bar खोलें (Script टैब पर या Window, फिर Script से) और workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame चलाएँ। एडिट मोड में CurrentCamera वह दृश्य है जिससे आप देख रहे हैं, इसलिए पार्ट ठीक इसी फ़्रेम में आ जाता है। ब्रैकेट और कोट ज़रूरी हैं, क्योंकि अंक से शुरू होने वाला नाम डॉट के बाद नहीं लिखा जा सकता।
  5. पार्ट की Properties में Anchored पर टिक करें, CanCollide, CanTouch और CanQuery से टिक हटाएँ और Transparency 1 करें। Anchored उसे मैप के आर-पार गिरने नहीं देता; बाकी सेटिंग उसे प्लेयर के रास्ते में आने, टच इवेंट चलाने और raycast रोकने से बचाती हैं।
  6. अगले दृश्यों के लिए दोहराएँ, पार्ट के नाम 2, 3 वगैरह रखते हुए और Command Bar वाली लाइन में नंबर बदलते हुए। CutsceneService शॉट नंबर के क्रम में चलाती है और पहले छूटे नंबर पर रुक जाती है, इसलिए नंबरिंग में खाली जगह कटसीन को समय से पहले ख़त्म कर देती है।

बाद में शॉट बदलने के लिए कैमरा नए दृश्य पर ले जाएँ और उसी शॉट के नंबर के साथ वही लाइन चलाएँ। Transparency 1 पर पार्ट Studio में भी अदृश्य होते हैं, इसलिए ज़रूरत पड़ने पर उन्हें Explorer में चुनें।

हर शॉट में तीन और वैकल्पिक attribute हो सकते हैं। attribute जोड़ने के लिए पार्ट चुनें, Properties विंडो को Attributes हिस्से तक स्क्रॉल करें, + दबाएँ, नाम लिखें, टाइप चुनें और Save दबाएँ।

हर शॉट पार्ट पर वैकल्पिक attribute
Attributeटाइपडिफ़ॉल्टक्या करता है
MoveSecondsnumber3कैमरा पिछले शॉट से इस शॉट तक कितने सेकंड में उड़ता है। 0 सीधा कट करता है। शॉट 1 हमेशा कट होता है, इसलिए उस पर यह attribute असर नहीं करता।
HoldSecondsnumber1पहुँचने के बाद कैमरा इस शॉट पर कितने सेकंड रुकता है।
Captionstringनहींकैमरे के इस शॉट की ओर उड़ना शुरू करने के पल से नीचे की पट्टी पर टेक्स्ट। बिना Caption वाला शॉट टेक्स्ट साफ़ कर देता है।

0 से कम या 60 से ज़्यादा संख्या, और गलत टाइप का attribute, डिफ़ॉल्ट मान से बदल दिए जाते हैं।

स्टेप 2: सर्वर स्क्रिप्ट जोड़ें

ServerScriptService पर कर्सर ले जाएँ, CutsceneService नाम की Script डालें और उसमें नीचे का कोड पेस्ट करें। ऊपर की सेटिंग वे लाइनें हैं जिन्हें आप बदल सकते हैं।

Script स्थान: ServerScriptService नाम: CutsceneService
-- ServerScriptService में CutsceneService नाम की Script।
-- तय करती है कि कौन कौन सी कटसीन कब देखे। Workspace.Cutscenes के नंबर वाले
-- पार्ट से कैमरा शॉट पढ़ती है, प्लेयर को अपनी जगह रोकती है और उस प्लेयर के
-- डिवाइस को शॉट चलाने को कहती है। कैमरा ख़ुद सिर्फ़ डिवाइस पर हिलाया जा सकता है।

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- सेटिंग
local INTRO_CUTSCENE = "Intro" -- प्लेयर के पहले स्पॉन पर एक बार चलती है; बंद करने के लिए ""
local DEFAULT_MOVE_SECONDS = 3 -- शॉट तक उड़ने का समय, अगर उसमें MoveSeconds नहीं है
local DEFAULT_HOLD_SECONDS = 1 -- शॉट पर रुकने का समय, अगर उसमें HoldSeconds नहीं है
local MAX_SHOTS = 30

local cutscenes = workspace:WaitForChild("Cutscenes")
local triggers = workspace:FindFirstChild("CutsceneTriggers")

-- यह स्क्रिप्ट CutsceneEvent ख़ुद बनाती है, इसलिए उसे हाथ से न जोड़ें
local cutsceneEvent = Instance.new("RemoteEvent")
cutsceneEvent.Name = "CutsceneEvent"
cutsceneEvent.Parent = ReplicatedStorage

type Shot = { cframe: CFrame, move: number, hold: number, caption: string }

local seen: { [Player]: { [string]: boolean } } = {}
local playing: { [Player]: number } = {} -- प्लेयर जो कटसीन देख रहा है उसका id
local lastId = 0

local function secondsAttribute(part: Instance, name: string, default: number): number
	local value = part:GetAttribute(name)
	if typeof(value) == "number" and value >= 0 and value <= 60 then
		return value
	end
	return default
end

-- शॉट कटसीन के नाम वाले फ़ोल्डर में 1, 2, 3 ... पार्ट हैं
local function readShots(name: string): { Shot }
	local shots: { Shot } = {}
	local folder = cutscenes:FindFirstChild(name)
	if not folder then
		warn(`CutsceneService: no folder named {name} in Workspace.Cutscenes`)
		return shots
	end
	for index = 1, MAX_SHOTS do
		local part = folder:FindFirstChild(tostring(index))
		if not (part and part:IsA("BasePart")) then
			break
		end
		local caption = part:GetAttribute("Caption")
		table.insert(shots, {
			cframe = part.CFrame,
			-- पहला शॉट कट है, इसलिए कैमरा सीधे उस पर कूदता है
			move = if index == 1 then 0 else secondsAttribute(part, "MoveSeconds", DEFAULT_MOVE_SECONDS),
			hold = secondsAttribute(part, "HoldSeconds", DEFAULT_HOLD_SECONDS),
			caption = if typeof(caption) == "string" then caption else "",
		})
	end
	return shots
end

local function setFrozen(player: Player, frozen: boolean)
	local character = player.Character
	local rootPart = character and character:FindFirstChild("HumanoidRootPart")
	if rootPart and rootPart:IsA("BasePart") then
		rootPart.Anchored = frozen
	end
end

local function finish(player: Player, id: number)
	if playing[player] ~= id then
		return -- यह कटसीन पहले ही ख़त्म हो चुकी
	end
	playing[player] = nil
	setFrozen(player, false)
end

local function play(player: Player, name: string): boolean
	if playing[player] then
		return false -- एक समय में एक कटसीन
	end
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 then
		return false
	end
	local shots = readShots(name)
	if #shots == 0 then
		return false
	end

	lastId += 1
	local id = lastId
	playing[player] = id

	-- instance streaming चालू होने पर प्लेयर के डिवाइस पर वह इलाका न हो, ऐसा हो सकता है
	-- जिसे शॉट देखता है, और रिक्वेस्ट इलाका सिर्फ़ कुछ समय के लिए लोड करती है। पहले शॉट का
	-- इलाका अभी लोड करते हैं (2 सेकंड तक इंतज़ार), और हर अगले शॉट का इलाका
	-- कैमरे के उसकी ओर उड़ने से 2 सेकंड पहले।
	local function request(position: Vector3)
		pcall(function()
			player:RequestStreamAroundAsync(position, 2)
		end)
	end
	request(shots[1].cframe.Position)
	if playing[player] ~= id or player.Parent ~= Players then
		return false -- इलाका लोड होते समय प्लेयर चला गया
	end

	setFrozen(player, true)
	cutsceneEvent:FireClient(player, id, shots)
	local startsAt = 0 -- अभी से इस शॉट की ओर उड़ान शुरू होने तक के सेकंड
	for index, shot in shots do
		if index > 1 then
			task.delay(math.max(startsAt - 2, 0), function()
				if playing[player] == id then
					request(shot.cframe.Position)
				end
			end)
		end
		startsAt += shot.move + shot.hold
	end
	-- सुरक्षा जाल: प्लेयर को आज़ाद करते हैं, चाहे उसका डिवाइस कभी जवाब न दे
	task.delay(startsAt + 2, finish, player, id)
	return true
end

-- true तभी लौटाता है जब इस प्लेयर के लिए कटसीन शुरू हुई
local function playOnce(player: Player, name: string): boolean
	local playerSeen = seen[player]
	if not playerSeen or playerSeen[name] then
		return false
	end
	if play(player, name) then
		playerSeen[name] = true
		return true
	end
	return false
end

-- प्लेयर का डिवाइस बताता है कि कटसीन ख़त्म हुई या स्किप हुई
cutsceneEvent.OnServerEvent:Connect(function(player: Player, id: unknown)
	if typeof(id) == "number" then
		finish(player, id)
	end
end)

-- ट्रिगर पार्ट: छूने पर उनके Cutscene attribute वाली कटसीन शुरू होती है
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- बंद CanTouch वाले पार्ट से Touched जोड़ने पर गलती आती है, इसलिए बस चेतावनी देते हैं
			warn(`CutsceneService: tick CanTouch on {trigger:GetFullName()} so it can start a cutscene`)
			continue
		end
		trigger.Touched:Connect(function(otherPart: BasePart)
			local name = trigger:GetAttribute("Cutscene")
			local character = otherPart:FindFirstAncestorOfClass("Model")
			local player = character and Players:GetPlayerFromCharacter(character)
			if player and typeof(name) == "string" then
				playOnce(player, name)
			end
		end)
	end
end

local function onCharacterAdded(player: Player, character: Model)
	character:WaitForChild("HumanoidRootPart", 10)
	if playing[player] then
		setFrozen(player, true) -- कटसीन के दौरान रीस्पॉन, नए कैरेक्टर को भी अपनी जगह रोकते हैं
	elseif INTRO_CUTSCENE ~= "" then
		playOnce(player, INTRO_CUTSCENE)
	end
end

local function onPlayerAdded(player: Player)
	if seen[player] then
		return -- पहले से सेट है
	end
	seen[player] = {}
	player.CharacterAdded:Connect(function(character: Model)
		onCharacterAdded(player, character)
	end)
	local character = player.Character
	if character then
		task.spawn(onCharacterAdded, player, character)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- वे सब जो स्क्रिप्ट के Cutscenes का इंतज़ार करते समय आ गए
	onPlayerAdded(player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	seen[player] = nil
	playing[player] = nil
end)

Workspace.Cutscenes दिखते ही CutsceneService ख़ुद CutsceneEvent RemoteEvent बनाती है, इसलिए ReplicatedStorage में हाथ से कुछ डालने की ज़रूरत नहीं। अगर आपने इस नाम का RemoteEvent पहले से बना लिया है, तो उसे हटा दें: LocalScript आपका वाला ढूँढ सकता है, जिसे सर्वर पर कोई नहीं सुनता।

CutsceneService के ऊपर की सेटिंग
सेटिंगयहाँ मानक्या बदलती है
INTRO_CUTSCENE"Intro"Workspace.Cutscenes का वह फ़ोल्डर जो सर्वर पर प्लेयर के पहले स्पॉन पर चलता है। इंट्रो न हो, इसके लिए "" रखें।
DEFAULT_MOVE_SECONDS3अगर शॉट में MoveSeconds attribute नहीं है, तो उड़ान कितनी देर चलती है।
DEFAULT_HOLD_SECONDS1अगर शॉट में HoldSeconds attribute नहीं है, तो कैमरा उस पर कितनी देर रुकता है।
MAX_SHOTS30एक कटसीन में CutsceneService जो सबसे बड़ा शॉट नंबर ढूँढती है।

स्क्रिप्ट का बाकी हिस्सा क्रम से क्या करता है:

  • शॉट सर्वर पर पढ़ती है। readShots हर नंबर वाले पार्ट का CFrame और attribute एक सूची में जमा करता है। प्लेयर के डिवाइस को यह सूची मिलती है, इसलिए उसे ख़ुद पार्ट की ज़रूरत नहीं।
  • एक समय में एक कटसीन। जब तक प्लेयर पहले से कोई कटसीन देख रहा है, या उसके कैरेक्टर में Humanoid नहीं है या वह मरा हुआ है, play कुछ नहीं करता।
  • हर कटसीन का अपना id। कटसीन ख़त्म होने या स्किप होने पर डिवाइस id वापस भेजता है, और प्लेयर को सिर्फ़ मेल खाता id ही आज़ाद करता है, इसलिए पिछली कटसीन का देर से आया संदेश नई कटसीन ख़त्म नहीं कर सकता।
  • प्लेयर को अपनी जगह रोकती है, उसका HumanoidRootPart Anchored करके, और अगर प्लेयर कटसीन के बीच रीस्पॉन हो तो नए कैरेक्टर को भी Anchored करती है। Roblox के रेफ़रेंस में लिखा है कि Anchored पार्ट गुरुत्व, टक्कर या दूसरी फ़िज़िक्स से कभी पोज़िशन नहीं बदलता। WalkSpeed को छुआ नहीं जाता, इसलिए यह स्प्रिंट स्क्रिप्ट या स्पीड पास से नहीं टकराता। आख़िर में स्क्रिप्ट root part से Anchored हटा देती है, चाहे उसे किसी दूसरी स्क्रिप्ट ने Anchored किया हो, इसलिए जब कटसीन चल सकती हो तब कैरेक्टर को कहीं और Anchored न करें।
  • सुरक्षा जाल। task.delay कटसीन की पूरी लंबाई और 2 सेकंड बाद प्लेयर को आज़ाद करता है, चाहे उसका डिवाइस कभी जवाब न दे।
  • हर सर्वर पर हर कटसीन एक बार। seen टेबल हर प्लेयर के लिए याद रखती है कि कौन सी कटसीन शुरू हो चुकी हैं, इसलिए इंट्रो रीस्पॉन पर नहीं दोहराता, और ट्रिगर वाली कटसीन एक बार चलती है। playOnce तभी true लौटाता है जब कटसीन सच में शुरू हुई।
  • हर प्लेयर को सेट करती है। आख़िर में Players:GetPlayers() पर लूप उन सबको पकड़ता है जो स्क्रिप्ट के Cutscenes फ़ोल्डर का इंतज़ार करते समय आ गए।

शॉट प्लेयर को एक FireClient कॉल में, छोटी टेबल की सूची के रूप में जाते हैं। Roblox के remote events पेज पर लिखा है कि ऐसी टेबल न भेजें जिसमें संख्या और स्ट्रिंग key मिली हों; इस सूची में सिर्फ़ संख्या वाली key हैं, और अंदर के हर शॉट में सिर्फ़ स्ट्रिंग key, यही वह रूप है जिसकी वहाँ सलाह दी गई है।

स्टेप 3: उसे चलाने वाला LocalScript जोड़ें

  1. Explorer में StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ और CutscenePlayer नाम का LocalScript डालें।
  2. उसकी सामग्री को नीचे के कोड से बदलें।
LocalScript स्थान: StarterPlayerScripts नाम: CutscenePlayer
-- StarterPlayer > StarterPlayerScripts में CutscenePlayer नाम का LocalScript।
-- सर्वर की भेजी कटसीन चलाता है: काली पट्टियाँ, कैप्शन, Skip बटन और
-- शॉट से शॉट तक उड़ता कैमरा। फिर कैमरा प्लेयर को लौटाता है।

local GuiService = game:GetService("GuiService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local StarterGui = game:GetService("StarterGui")
local TweenService = game:GetService("TweenService")
local UserInputService = game:GetService("UserInputService")

local cutsceneEvent = ReplicatedStorage:WaitForChild("CutsceneEvent") :: RemoteEvent
local player = Players.LocalPlayer
local camera = workspace.CurrentCamera

local BAR_HEIGHT = 0.12 -- हर काली पट्टी, स्क्रीन की ऊँचाई के हिस्से के रूप में
local EASING_STYLE = Enum.EasingStyle.Sine
local FOCUS_DISTANCE = 30 -- कैमरे के आगे कितने स्टड तक Roblox सबसे ज़्यादा बारीकी से बनाए
local HIDDEN_CORE_GUIS = { Enum.CoreGuiType.PlayerList, Enum.CoreGuiType.Backpack, Enum.CoreGuiType.Health }
local REGULAR = Font.fromEnum(Enum.Font.BuilderSans)
local BOLD = Font.fromEnum(Enum.Font.BuilderSansBold)

type Shot = { cframe: CFrame, move: number, hold: number, caption: string }

-- कटसीन स्क्रीन: दो काली पट्टियाँ और कैप्शन, किनारे से किनारे तक। Roblox ScreenInsets None
-- सिर्फ़ उस चीज़ के लिए सुझाता है जिसे कोई दबाता नहीं, इसलिए नीचे Skip का अपना ScreenGui है।
local gui = Instance.new("ScreenGui")
gui.Name = "Cutscene"
gui.ResetOnSpawn = false
gui.ScreenInsets = Enum.ScreenInsets.None -- पूरी स्क्रीन पर
gui.DisplayOrder = 10
gui.Enabled = false

local topBar = Instance.new("Frame")
topBar.Size = UDim2.fromScale(1, BAR_HEIGHT)
topBar.BackgroundColor3 = Color3.new(0, 0, 0)
topBar.BorderSizePixel = 0
topBar.Parent = gui

local bottomBar = topBar:Clone()
bottomBar.Position = UDim2.fromScale(0, 1 - BAR_HEIGHT)
bottomBar.Parent = gui

local caption = Instance.new("TextLabel")
caption.Size = UDim2.fromScale(0.7, 0.5)
caption.Position = UDim2.fromScale(0.15, 0.25)
caption.BackgroundTransparency = 1
caption.TextColor3 = Color3.new(1, 1, 1)
caption.TextScaled = true
caption.FontFace = REGULAR
caption.Text = ""
caption.Parent = bottomBar

-- Skip बटन में डिफ़ॉल्ट insets हैं, इसलिए कैमरा कटआउट उसे नहीं ढकता
local controls = Instance.new("ScreenGui")
controls.Name = "CutsceneControls"
controls.ResetOnSpawn = false
controls.DisplayOrder = 11
controls.Enabled = false

local skipButton = Instance.new("TextButton")
skipButton.AnchorPoint = Vector2.new(1, 0.5)
skipButton.Size = UDim2.fromScale(0.1, BAR_HEIGHT * 0.5)
skipButton.Position = UDim2.new(1, -16, 1 - BAR_HEIGHT / 2, 0) -- नीचे की पट्टी पर, दाईं ओर
skipButton.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
skipButton.TextColor3 = Color3.new(1, 1, 1)
skipButton.TextScaled = true
skipButton.FontFace = BOLD
skipButton.Text = "Skip"
skipButton.Parent = controls

-- Skip इतना बड़ा रहता है कि छोटे फ़ोन पर भी उस पर टैप हो सके
local skipMinSize = Instance.new("UISizeConstraint")
skipMinSize.MinSize = Vector2.new(64, 32)
skipMinSize.Parent = skipButton

local playerGui = player:WaitForChild("PlayerGui")
gui.Parent = playerGui
controls.Parent = playerGui

-- मौजूदा उड़ान: एक कैमरा CFrame से अगले तक तय सेकंड में
local moveFrom = CFrame.identity
local moveTo = CFrame.identity
local moveStart = 0
local moveSeconds = 0
local skipRequested = false
local busy = false

-- कटसीन के दौरान हर फ़्रेम चलता है। Scriptable कैमरे का Focus ख़ुद किसी चीज़ के पीछे
-- नहीं चलता, इसलिए वह भी यहीं सेट होता है।
local function updateCamera()
	if camera.CameraType ~= Enum.CameraType.Scriptable then
		camera.CameraType = Enum.CameraType.Scriptable -- किसी चीज़ ने उसे रीसेट किया, जैसे रीस्पॉन
	end
	local alpha = if moveSeconds > 0 then (os.clock() - moveStart) / moveSeconds else 1
	local eased = TweenService:GetValue(alpha, EASING_STYLE, Enum.EasingDirection.InOut)
	camera.CFrame = moveFrom:Lerp(moveTo, eased)
	camera.Focus = camera.CFrame * CFrame.new(0, 0, -FOCUS_DISTANCE)
end

local function waitOrSkip(seconds: number)
	local endTime = os.clock() + seconds
	while os.clock() < endTime and not skipRequested do
		task.wait()
	end
end

local function play(id: number, shots: { Shot })
	if busy then
		-- एक पहले से चल रही है, इसलिए सर्वर इस वाली के लिए प्लेयर को तुरंत आज़ाद करे
		cutsceneEvent:FireServer(id)
		return
	end
	busy = true
	skipRequested = false

	-- प्लेयर लिस्ट, बैकपैक और हेल्थ बार छिपाते हैं, याद रखते हुए कि क्या दिख रहा था
	local wasEnabled: { [Enum.CoreGuiType]: boolean } = {}
	for _, coreGui in HIDDEN_CORE_GUIS do
		wasEnabled[coreGui] = StarterGui:GetCoreGuiEnabled(coreGui)
		StarterGui:SetCoreGuiEnabled(coreGui, false)
	end
	-- फ़ोन पर स्टिक और जंप बटन छिपाते हैं, जो नीचे के कोनों में हैं
	local touchControlsWere = GuiService.TouchControlsEnabled
	GuiService.TouchControlsEnabled = false
	gui.Enabled = true
	controls.Enabled = true
	-- गेमपैड सिर्फ़ चुना हुआ बटन दबा सकता है, इसलिए गेमपैड वाले प्लेयर के लिए Skip चुनते हैं
	if UserInputService.PreferredInput == Enum.PreferredInput.Gamepad then
		GuiService.SelectedObject = skipButton
	end
	camera = workspace.CurrentCamera
	camera.CameraType = Enum.CameraType.Scriptable
	moveTo = camera.CFrame
	-- Roblox के अपने कैमरा अपडेट के एक स्टेप बाद, जैसा Roblox के कैमरा ट्यूटोरियल में है
	RunService:BindToRenderStep("Cutscene", Enum.RenderPriority.Camera.Value + 1, updateCamera)

	for _, shot in shots do
		moveFrom = camera.CFrame -- हर उड़ान वहीं से शुरू करते हैं जहाँ कैमरा अभी है
		moveTo = shot.cframe
		moveStart = os.clock()
		moveSeconds = shot.move
		caption.Text = shot.caption
		waitOrSkip(shot.move + shot.hold)
		if skipRequested then
			break
		end
	end

	-- कैमरा प्लेयर के कैरेक्टर को लौटाते हैं
	RunService:UnbindFromRenderStep("Cutscene")
	camera.CameraType = Enum.CameraType.Custom
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid then
		camera.CameraSubject = humanoid
	end
	if GuiService.SelectedObject == skipButton then
		GuiService.SelectedObject = nil
	end
	gui.Enabled = false
	controls.Enabled = false
	caption.Text = ""
	-- सिर्फ़ वही वापस चालू करते हैं जो इस कटसीन ने बंद किया, बाकी को नहीं छूते
	for coreGui, enabled in wasEnabled do
		if enabled then
			StarterGui:SetCoreGuiEnabled(coreGui, true)
		end
	end
	if touchControlsWere then
		GuiService.TouchControlsEnabled = true
	end
	cutsceneEvent:FireServer(id) -- सर्वर प्लेयर को तुरंत आज़ाद करता है
	busy = false
end

skipButton.Activated:Connect(function()
	skipRequested = true
end)

cutsceneEvent.OnClientEvent:Connect(function(id: number, shots: { Shot })
	play(id, shots)
end)

StarterPlayerScripts का LocalScript प्लेयर को एक बार, जॉइन करते समय, कॉपी होता है और कैरेक्टर के रीस्पॉन के बाद भी चलता रहता है। इसीलिए दोनों ScreenGui में ResetOnSpawn बंद है: इसे चालू करें तो Roblox पहले रीस्पॉन पर उन्हें हटा देगा, और यह स्क्रिप्ट उन्हें फिर से नहीं बनाएगी। स्क्रिप्ट के OnClientEvent से जुड़ने से पहले आए रिमोट संदेश कतार में रखे जाते हैं और जुड़ने के बाद पहुँचाए जाते हैं, इसलिए जल्दी स्पॉन हुआ प्लेयर भी इंट्रो देखेगा।

CutscenePlayer का हर हिस्सा क्या करता है
हिस्साक्या करता है
ScreenGui Cutsceneदो काली पट्टियाँ, हर एक स्क्रीन की ऊँचाई का 12% (BAR_HEIGHT), और नीचे की पट्टी पर कैप्शन। ScreenInsets None पट्टियों को स्क्रीन के बिल्कुल किनारों तक फैलाता है, और DisplayOrder 10 उन्हें कम DisplayOrder वाले ScreenGui के ऊपर बनाता है।
ScreenGui CutsceneControlsइसमें सिर्फ़ Skip बटन है, नीचे की पट्टी पर दाईं ओर, UISizeConstraint के साथ जो उसे कम से कम 64 x 32 पिक्सेल रखता है, ताकि फ़ोन पर उस पर आसानी से टैप हो। इसमें डिफ़ॉल्ट ScreenInsets है, और सामग्री Roblox के ऊपरी पैनल के बटन और कैमरा कटआउट के नीचे नहीं जाती। Roblox None सिर्फ़ उस सामग्री के लिए सुझाता है जिसमें दबाने को कुछ न हो, इसलिए Skip पट्टियों वाले ScreenGui में नहीं रह सकता।
HIDDEN_CORE_GUISSetCoreGuiEnabled से प्लेयर लिस्ट, बैकपैक और हेल्थ बार छिपाता है, उससे पहले GetCoreGuiEnabled से याद रखता है कि कौन से चालू थे, और आख़िर में सिर्फ़ वही वापस चालू करता है जो उसने ख़ुद बंद किए। अगर गेम कहीं और बैकपैक छिपाता है, तो वह छिपा ही रहेगा, और कटसीन के दौरान उन्हें चालू करने वाली स्क्रिप्ट, जैसे मेन मेनू, को कोई नहीं काटता।
TouchControlsEnabledफ़ोन और टैबलेट पर play कटसीन के दौरान GuiService.TouchControlsEnabled को false करता है। इससे स्टिक और जंप बटन छिप जाते हैं, जो नीचे के कोनों में होते हैं, वहीं जहाँ Skip है, और आख़िर में अगर वे चालू थे तो लौट आते हैं।
updateCameraकटसीन चलते समय हर फ़्रेम चलता है। गिनता है कि मौजूदा उड़ान का कितना हिस्सा पूरा हुआ, उसे TweenService:GetValue से स्मूथ करता है, CFrame:Lerp से कैमरा दो शॉट के बीच रखता है और Focus कैमरे से 30 स्टड आगे सेट करता है।
waitOrSkipउड़ान और शॉट पर रुकने का समय इंतज़ार करता है, हर फ़्रेम Skip फ़्लैग जाँचते हुए।
playकैमरा Scriptable करता है, शॉट क्रम से चलाता है, फिर कैमरा लौटाता है (CameraType Custom, CameraSubject Humanoid), core GUI और टच कंट्रोल वापस चालू करता है और सर्वर को कटसीन का id भेजता है। अगर पहली कटसीन चलते समय दूसरी आ जाए, तो वह तुरंत उसका id वापस भेज देता है, ताकि सर्वर प्लेयर को ऐसी कटसीन के लिए न रोके जो इस डिवाइस ने नहीं दिखाई।
Skip बटनबटन चुना होने पर Activated माउस क्लिक, टैप या गेमपैड के A बटन पर चलता है। जिस प्लेयर का मुख्य इनपुट गेमपैड है, उसके लिए play कटसीन की शुरुआत में Skip चुनता है और आख़िर में चुनाव हटाता है।

पट्टियाँ पतली या मोटी करने के लिए BAR_HEIGHT बदलें, और उड़ान का एहसास बदलने के लिए EASING_STYLE (देखें कैमरा कोड क्या सही करता है)। कैप्शन और Skip बटन में TextScaled चालू है, इसलिए टेक्स्ट स्क्रीन के साथ बड़ा-छोटा होता है।

स्टेप 4: पार्ट छूने पर कटसीन

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

  1. Workspace, Cutscenes में Bridge नाम का Folder डालें और स्टेप 1 की तरह उसके शॉट रखें, नाम 1 और 2। Command Bar वाली लाइन में Intro की जगह Bridge लिखें।
  2. Workspace पर कर्सर ले जाएँ और CutsceneTriggers नाम का Folder डालें।
  3. उसमें BridgeTrigger नाम का Part डालें। उसे इतना बड़ा बनाएँ कि प्लेयर उसे छुए बिना निकल न सकें, जैसे सड़क के आर-पार एक ऊँची चौड़ी स्लैब। Anchored पर टिक करें, CanCollide और CanQuery से टिक हटाएँ, CanTouch पर टिक रहने दें और Transparency 1 करें। बंद CanQuery अदृश्य स्लैब को raycast रोकने से बचाता है, जैसे गन गाइड की गोलियाँ। टच इवेंट CanTouch से चलते हैं, CanQuery से नहीं, इसलिए ट्रिगर फिर भी काम करता है।
  4. उसमें string टाइप का Cutscene attribute जोड़ें और मान Bridge दें: वह फ़ोल्डर जिसे चलाना है।

सर्वर शुरू होने पर CutsceneService, CutsceneTriggers के ठीक अंदर के हर पार्ट से Touched जोड़ती है, इसलिए ट्रिगर Studio में जोड़ें, गेम के दौरान स्क्रिप्ट से नहीं। बंद CanTouch वाला ट्रिगर Output में चेतावनी के साथ छोड़ दिया जाता है, क्योंकि जब स्क्रिप्ट ऐसे पार्ट से Touched जोड़ती है तो Roblox गलती देता है।

जब तक कैरेक्टर पार्ट के आर-पार चलता है, Touched लगातार कई बार चलता है। seen टेबल और "एक समय में एक कटसीन" नियम इसे हर सर्वर पर हर प्लेयर के लिए एक कटसीन बना देते हैं। जो प्लेयर किसी दूसरी कटसीन के दौरान ट्रिगर छूता है, उसे अनदेखा किया जाता है, और ट्रिगर उसके लिए तैयार रहता है।

ट्रिगर सड़कों पर न रखें। बैठे हुए प्लेयर का HumanoidRootPart सीट से वेल्ड होता है, और जब वेल्ड किए समूह का एक पार्ट Anchored होता है, तो Roblox बाकी को भी उसके साथ Anchored कर देता है। इसलिए जो प्लेयर गाड़ी से ट्रिगर में घुसता है, वह कटसीन ख़त्म होने तक अपनी पूरी गाड़ी को, सवारियों समेत, अपनी जगह रोक देता है।

कैमरा कोड क्या सही करता है

Scriptable, फिर वापस Custom

जब तक CameraType Scriptable है, Roblox की कैमरा स्क्रिप्ट कैमरा न हिलाती हैं न अपडेट करती हैं, और यही CutscenePlayer को उसे सेट करने देता है। आख़िर में वह CameraType को वापस Custom करता है और प्लेयर के Humanoid को CameraSubject बनाता है, जिसके पीछे Roblox की कैमरा स्क्रिप्ट डिफ़ॉल्ट रूप से चलती हैं। यह Skip के बाद भी होता है, इसलिए प्लेयर कभी आख़िरी शॉट को घूरता नहीं रह जाता।

दो छोटी जाँचें कटसीन चलते समय उसे मुख्य बनाए रखती हैं। अगर कटसीन के बीच कोई चीज़ CameraType को दूसरे मान पर कर दे, तो हर फ़्रेम चलने वाला फ़ंक्शन अगले फ़्रेम पर Scriptable लौटा देता है। और workspace.CurrentCamera को स्क्रिप्ट हर कटसीन की शुरुआत में फिर से पढ़ती है, क्योंकि अगर मौजूदा Camera कभी हटा दिया जाए तो Roblox नया बनाता है।

Focus, हर फ़्रेम

Camera.Focus इंजन को बताता है कि लाइटिंग जैसे काम में किस इलाके को प्राथमिकता देनी है। Roblox की कैमरा स्क्रिप्ट उसे CameraSubject पर रखती हैं, लेकिन तब नहीं जब कैमरा Scriptable हो, और Roblox के रेफ़रेंस में इस हालत में उसे हर फ़्रेम अपडेट करने को कहा गया है: PointLight जैसी चीज़ों की डायनैमिक रोशनी फ़ोकस से दूर शायद न बने। CutscenePlayer उसे कैमरे से 30 स्टड आगे रखता है (FOCUS_DISTANCE)। अगर आपके शॉट किसी और दूर की चीज़ को देखते हैं, तो यह संख्या बढ़ाएँ।

फ़ंक्शन RunService:BindToRenderStep से चलता है, हर फ़्रेम बनने से पहले, Roblox के अपने कैमरा अपडेट के एक प्रायोरिटी स्टेप बाद (Enum.RenderPriority.Camera.Value + 1)। यही प्रायोरिटी Roblox का कैमरा ट्यूटोरियल इस्तेमाल करता है, इसलिए कटसीन कैमरा तब सेट करती है जब Roblox का अपना कैमरा कोड चल चुका हो।

TweenService:GetValue से स्मूथ करना

camera.CFrame पर ट्वीन कैमरा हिला देता, लेकिन Focus फिर भी हर फ़्रेम सेट करना पड़ता, इसलिए CutscenePlayer उसी फ़ंक्शन में कैमरा ख़ुद हिलाता है। हर उड़ान के लिए वह गिनता है कि समय का कितना हिस्सा बीता (0 से 1), उसे easing स्टाइल और दिशा के साथ TweenService:GetValue से गुज़ारता है, और CFrame:Lerp से कैमरे को दो शॉट के बीच रास्ते के उतने हिस्से पर रखता है, जो पोज़िशन को सीधी लाइन में ले जाता है और धीरे-धीरे घुमाता है। GetValue इनपुट को 0 और 1 के बीच सीमित करता है, इसलिए उड़ान का समय ख़त्म होने पर कैमरा ठीक शॉट पर रुकता है।

कैमरे की उड़ान के लिए ठीक easing स्टाइल
EASING_STYLEउड़ान कैसी लगती है
Enum.EasingStyle.Sine (यहाँ)रफ़्तार साइन वेव जैसी, नरम शुरुआत और नरम रुकना।
Enum.EasingStyle.QuadSine जैसी, लेकिन कर्व थोड़ा तीखा।
Enum.EasingStyle.Linearएक जैसी रफ़्तार, इसलिए हर उड़ान पूरी रफ़्तार पर शुरू और ख़त्म होती है।

दिशा InOut: easing उड़ान के पहले आधे में आगे की ओर और दूसरे आधे में उल्टी ओर लगता है, इसलिए कैमरा एक शॉट से तेज़ होता है और अगले की ओर धीमा होता है।

स्ट्रीमिंग

नए place में instance streaming चालू होता है: डिफ़ॉल्ट रूप से प्लेयर का डिवाइस उसके कैरेक्टर के आसपास का इलाका रखता है, इसलिए मैप के दूसरे छोर को देखने वाला शॉट ख़ाली दुनिया दिखा सकता है। CutsceneService, Player:RequestStreamAroundAsync से Roblox से उस प्लेयर के लिए हर शॉट का इलाका लोड करने को कहती है: पहले शॉट का इलाका इवेंट भेजने से पहले, 2 सेकंड तक इंतज़ार के साथ, और हर अगले शॉट का इलाका कैमरे के उसकी ओर उड़ने से 2 सेकंड पहले।

Roblox लिखता है कि इससे इलाका शायद, पर पक्के तौर पर नहीं, लोड होगा, और असर अस्थायी है। ज़रूरी शॉट स्ट्रीमिंग के दायरे में रखें, या सर्वर पर उस इलाके के लिए Player:AddReplicationFocus इस्तेमाल करें जिसे तब तक लोड रहना है जब तक आप फ़ोकस न हटाएँ। स्ट्रीमिंग बंद होने पर डिवाइस के पास वैसे भी पूरा मैप होता है, और हर रिक्वेस्ट के आसपास pcall का मतलब है कि असफल रिक्वेस्ट कटसीन नहीं रोक सकती।

पुराने कटसीन ट्यूटोरियल में क्या गलत है

अगर आप इस गाइड की तुलना किसी वीडियो या फ़ोरम पोस्ट से कर रहे हैं, तो ये फ़र्क़ मायने रखते हैं, और हर तरीका समस्या क्यों है।

कटसीन ट्यूटोरियल के आम तरीके और यह गाइड उनकी जगह क्या करती है
ट्यूटोरियलसमस्यायह गाइड
कैमरा camera:Interpolate() से हिलाता हैRoblox ने Interpolate को deprecated बताया है और कैमरा TweenService से ऐनिमेट करने की सलाह देता है।हर उड़ान TweenService:GetValue से स्मूथ करती है और हर फ़्रेम कैमरा सेट करती है।
camera.CFrame ट्वीन करता है और कुछ नहींFocus वहीं रहता है जहाँ कैमरा स्क्रिप्ट ने छोड़ा, कैरेक्टर के पास, इसलिए उससे दूर की डायनैमिक रोशनी शायद न बने (Camera.Focus पर Roblox रेफ़रेंस)।render step में हर फ़्रेम Focus सेट करती है।
कैमरा नहीं लौटाताप्लेयर आख़िरी शॉट को घूरता अटक जाता है।आख़िर में CameraType को Custom और CameraSubject को Humanoid पर करती है, Skip के बाद भी।
कटसीन LocalScript के Touched से शुरू करता हैउसे हर बार छूने पर दोहराने से कोई नहीं रोकता, और फ़ैसला उस डिवाइस पर होता है जिसे प्लेयर नियंत्रित करता है।सर्वर प्लेयर चुनता है और याद रखता है कि किसने उसे पहले देख लिया।
कैमरा पार्ट क्लाइंट पर पढ़ता हैस्ट्रीमिंग चालू होने पर कैरेक्टर से दूर के पार्ट अभी डिवाइस पर मौजूद न हों, ऐसा हो सकता है।सर्वर पार्ट पढ़ता है, उनके CFrame भेजता है और कैमरे के पहुँचने से थोड़ा पहले हर शॉट का इलाका माँगता है।

प्लेयर क्या बदल सकता है और क्या नहीं

मान लें कि चीटर अपने डिवाइस पर सब कुछ नियंत्रित करता है: वह CutscenePlayer को बदल या हटा सकता है और किसी भी मान के साथ CutsceneEvent भेज सकता है। कटसीन के लिए इसका लगभग कोई मतलब नहीं, अगर उस पर कोई असली चीज़ निर्भर न हो।

चीटर क्या आज़मा सकता है और उससे क्या होगा
चीटर कोशिश करता हैनतीजा
कटसीन स्किप करना या उसे चलाना ही नहींकर सकता है: यह उसकी अपनी स्क्रीन है। "कटसीन पूरी देखी" के लिए कभी इनाम न दें।
किसी भी मान के साथ CutsceneEvent भेजनासिर्फ़ उसकी मौजूदा कटसीन से मेल खाती संख्या कुछ करती है, और वह बस उसे जल्दी आज़ाद करती है।
मैप में कहीं से भी ट्रिगर छूनामुमकिन: हर डिवाइस अपना कैरेक्टर नियंत्रित करता है, और Roblox के सुरक्षा डॉक्यूमेंटेशन में Touched इवेंट की नक़ल उन चीज़ों में बताई गई है जो वह कर सकता है। वह यह कटसीन एक बार देखेगा, और कुछ नहीं होगा।
कटसीन के दौरान फिर भी हिलनाजीतने को कुछ नहीं। रोकना ईमानदार प्लेयर को कटसीन के बीच चले जाने से बचाता है; यह सुरक्षा जाँच नहीं है।
रिमोट से किसी और के लिए कटसीन चलानानामुमकिन। प्लेयर को CutsceneEvent सिर्फ़ सर्वर भेज सकता है, और डिवाइस वापस सिर्फ़ "यह कटसीन ख़त्म हुई" भेज सकता है।

अगर कटसीन किसी असली चीज़ तक ले जाती है, जैसे बाद में खुलने वाला दरवाज़ा या बॉस का आना, तो सर्वर उसे अपने टाइमर से करे, तब नहीं जब डिवाइस बताए कि कटसीन ख़त्म हुई।

स्टेप 5: जाँचें

  1. Command Bar वाली लाइन से Intro के तीन शॉट रखें। शॉट 1 को Caption "Welcome to the village" दें, शॉट 2 को MoveSeconds 2.5 और Caption "Find the bridge", और शॉट 3 को बिना attribute छोड़ें।
  2. Play (F5) दबाएँ। काली पट्टियाँ आती हैं, कैमरा अपने कैप्शन के साथ शॉट 1 पर कट करता है, 2.5 सेकंड में शॉट 2 तक उड़ता है, फिर 3 सेकंड में बिना कैप्शन के शॉट 3 तक। फिर कैमरा कैरेक्टर के पीछे लौटता है, और प्लेयर लिस्ट फिर दिखती है। चलते समय आप चल नहीं सकते।
  3. टेस्ट रोकें, फिर Play दबाएँ, और जब कैमरा शॉट 2 की ओर उड़ रहा हो तब Skip दबाएँ। कैमरा तुरंत लौटता है, और आप तुरंत चल सकते हैं।
  4. BridgeTrigger में जाएँ: Bridge कटसीन चलती है। उसके आर-पार फिर से जाएँ: कुछ नहीं होता।
  5. टेस्ट मोड की ड्रॉपडाउन लिस्ट में Server & Clients चुनें, 2 क्लाइंट रखें और Play दबाएँ। जब Client 1 ट्रिगर में जाता है, तो Bridge कटसीन सिर्फ़ Client 1 के लिए चलती है, और Client 2 चल सकता है।
  6. Workspace.StreamingEnabled चालू रहने दें और एक शॉट को स्पॉन से दूर ले जाएँ। कैमरे के पहुँचने पर आसपास का माहौल मौजूद होना चाहिए (शायद, पर पक्का नहीं: देखें स्ट्रीमिंग)।
  7. गेमपैड के लिए टेस्ट रोकें, Play दबाएँ, Controller Emulator खोलें (Emulation टैब, फिर Controller) और एमुलेट किए गेमपैड से BridgeTrigger में जाएँ: Skip चुना होना चाहिए, ताकि A कटसीन स्किप करे। अगर आप Studio का Device Simulator इस्तेमाल करते हैं (15 अक्टूबर 2026 को हमारी जाँच के समय यह बीटा है: File, Beta Features, New Device Simulator में चालू करें और Studio दोबारा शुरू करें), तो कोई फ़ोन चुनें, उसे आड़ा घुमाएँ और जाँचें कि Skip कैमरा कटआउट के नीचे नहीं जाता और उस पर आसानी से टैप होता है, और कटसीन चलते समय स्टिक और जंप बटन छिपे हैं।
  8. अगर आपने मेन मेनू भी बनाया है, तो Play दबाएँ, फिर मेनू का Play बटन, और इंट्रो को पूरा चलने दें: उसके बाद प्लेयर लिस्ट फिर स्क्रीन पर होनी चाहिए।

पूरे समय Output विंडो खुली रखें (Window मेनू, फिर Output)। सब ठीक चलने पर ये स्क्रिप्ट कुछ नहीं लिखतीं, इसलिए CutsceneService या CutscenePlayer की हर चेतावनी या लाल गलती असली समस्या है। देखें आम गलतियाँ।

सिस्टम को आगे कैसे बढ़ाएँ

इंट्रो सिर्फ़ प्लेयर के पहली बार आने पर

seen टेबल एक सर्वर तक रहती है, इसलिए दोबारा जॉइन करने वाला प्लेयर इंट्रो फिर देखता है। उसे सिर्फ़ पहली बार दिखाने के लिए एक flag, जैसे SeenIntro, प्लेयर के बाकी डेटा के साथ DataStore ट्यूटोरियल के PlayerData मॉड्यूल से सेव करें। INTRO_CUTSCENE जैसा है वैसा छोड़ें और CutsceneService में onCharacterAdded का वह हिस्सा बदलें जो इंट्रो संभालता है: PlayerData.Get(player) के प्लेयर का डेटा लौटाने तक इंतज़ार करें, अगर data.SeenIntro true है तो इंट्रो छोड़ दें, और data.SeenIntro = true तभी सेट करें जब playOnce(player, INTRO_CUTSCENE) ने true लौटाया हो। डेटा लोड करने वाले कोड से इंट्रो शुरू न करें: डेटा कैरेक्टर के स्पॉन होने से पहले लोड हो सकता है, और कैरेक्टर के बिना play कुछ नहीं करता, और flag ऐसे इंट्रो के लिए सेव हो जाएगा जिसे किसी ने नहीं देखा।

कटसीन में अभिनय करने वाले कैरेक्टर

Studio के Animation Editor में या किसी तीसरे पक्ष के ऐनिमेशन प्लगइन में ऐनिमेशन बनाएँ, जैसे Moon Animator, जिसका ज़िक्र Roblox के डॉक्यूमेंटेशन में है, और कैमरे के पहुँचने पर उसे शॉट में NPC रिग पर चलाएँ। Animator पर Roblox के रेफ़रेंस में लिखा है कि NPC के ऐनिमेशन तभी रेप्लिकेट होते हैं जब उन्हें सर्वर लोड करके चलाए, इसलिए अगर सब प्लेयर को NPC का अभिनय दिखना चाहिए, तो उसे सर्वर Script से चलाएँ। अगर उसे CutscenePlayer में लोड करके चलाएँ, तो ऐनिमेशन रेप्लिकेट नहीं होता, और यह उस कटसीन के लिए ठीक है जिसे सिर्फ़ एक प्लेयर देखता है। ऐनिमेशन स्क्रिप्ट गाइड दिखाती है कि सर्वर Script से NPC पर ऐनिमेशन कैसे चलाएँ।

डायलॉग

कैप्शन उन छोटी लाइनों के लिए ठीक हैं जो अपने आप चलती हैं। ऐसी बातचीत के लिए जहाँ प्लेयर जवाब देता है और विकल्प चुनता है, देखें NPC डायलॉग गाइड।

मेन मेनू के बाद इंट्रो

मेन मेनू गाइड CharacterAutoLoads बंद करती है, इसलिए जब तक कोई Play न दबाए, कोई स्पॉन नहीं होता। CutsceneService प्लेयर के पहले स्पॉन पर इंट्रो चलाती है, इसलिए दोनों सिस्टम के साथ इंट्रो Play के बाद पहले स्पॉन पर चलता है। कैरेक्टर आने पर मेनू core GUI वापस चालू करता है, और ऐसा तब हो सकता है जब इंट्रो पहले से चल रहा हो, इसलिए इंट्रो के दौरान प्लेयर लिस्ट दिख सकती है। CutscenePlayer सिर्फ़ वही वापस चालू करता है जो उसने ख़ुद छिपाया, इसलिए मेनू के बदलाव को नहीं छूता, और इंट्रो के बाद वे चालू रहते हैं। कैमरा पार्ट सेट करने के लिए मेन मेनू गाइड की Command Bar वाली तरकीब वही है जो स्टेप 1 में है।

राउंड की शुरुआत में मैप का चक्कर

किसी दूसरी सर्वर स्क्रिप्ट से कटसीन चलाने के लिए, जैसे राउंड सिस्टम गाइड से राउंड की शुरुआत में मैप का चक्कर, ServerStorage में PlayCutscene नाम का BindableEvent जोड़ें। CutsceneService के आख़िर में उसका Event play फ़ंक्शन से जोड़ें, और राउंड स्क्रिप्ट उसे हर प्लेयर और कटसीन के नाम के साथ कॉल करे। play "हर सर्वर पर एक बार" जाँच छोड़ देता है, इसलिए चक्कर हर राउंड चलता है।

कटसीन प्लगइन

प्लगइन इस गाइड के साथ इस्तेमाल किए जा सकते हैं। अगर कोई कटसीन प्लगइन अपनी कैमरा स्क्रिप्ट लिखता है, तो जाँचें कि वह कैमरा लौटाता है (CameraType Custom और CameraSubject) और कैमरा Scriptable रहने तक Focus सेट करता है, और कटसीन कौन देखे इसका फ़ैसला सर्वर पर रहने दें, जैसा इस गाइड में है।

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

Play दबाने से पहले Output विंडो खोलें (Window मेनू, फिर Output)। कटसीन की ज़्यादातर समस्याएँ या तो वहाँ चेतावनी लिखती हैं, या किसी ऐसे नाम से आती हैं जो मेल नहीं खाता।

Infinite yield possible on 'Workspace:WaitForChild("Cutscenes")'

CutsceneService सीधे Workspace में Cutscenes नाम के फ़ोल्डर का इंतज़ार कर रही है। उसे स्टेप 1 की तरह बनाएँ और स्पेलिंग और बड़ा C जाँचें। जब तक वह नहीं है, CutsceneService, CutsceneEvent नहीं बनाती, इसलिए CutscenePlayer भी इंतज़ार करता है।

Infinite yield possible on 'ReplicatedStorage:WaitForChild("CutsceneEvent")'

CutscenePlayer उस रिमोट का इंतज़ार कर रहा है जिसे CutsceneService बनाती है। जाँचें कि CutsceneService Script है, LocalScript नहीं, सीधे ServerScriptService में है, बंद नहीं है, और Output में उसकी Cutscenes से जुड़ी कोई गलती या चेतावनी नहीं है।

CutsceneService: no folder named Intro in Workspace.Cutscenes

INTRO_CUTSCENE का नाम या ट्रिगर के Cutscene attribute का नाम Workspace.Cutscenes के अंदर किसी फ़ोल्डर से मेल नहीं खाता। नामों में अक्षरों का केस मायने रखता है।

कुछ नहीं चलता, और Output ख़ाली है

फ़ोल्डर में 1 नाम का पार्ट नहीं है, या उसके पार्ट सीधे उसमें नहीं हैं (जैसे, किसी Model के अंदर)। CutsceneService पार्ट 1, 2, 3 क्रम से पढ़ती है और पहले छूटे नंबर पर रुक जाती है। और याद रखें कि हर कटसीन हर सर्वर पर हर प्लेयर के लिए एक बार चलती है: टेस्ट रोकें और फिर Play दबाएँ।

कैमरा गलत ओर देखता है

कैमरा उसी ओर देखता है जिधर शॉट पार्ट का आगे का हिस्सा है। Studio का कैमरा चाहे गए दृश्य पर ले जाएँ और उस शॉट के लिए स्टेप 1 की Command Bar वाली लाइन फिर चलाएँ।

ट्रिगर कुछ नहीं करता

जाँचें कि गेम शुरू होने पर ट्रिगर पार्ट सीधे Workspace.CutsceneTriggers के अंदर है, CanTouch पर टिक है (वरना Output में चेतावनी होगी), और उसका Cutscene attribute Workspace.Cutscenes के किसी फ़ोल्डर के नाम वाली string है। ट्रिगर के आर-पार दोबारा जाने पर कुछ नहीं होता, यह जान-बूझकर है।

कटसीन के बाद कैमरा आख़िरी शॉट पर रह जाता है

CutscenePlayer कैमरा लौटाने से पहले गलती से रुक गया, इसलिए Output में उसकी लाल गलती ढूँढें। कैमरे को कोई दूसरी स्क्रिप्ट भी पकड़े रख सकती है जो लगातार CameraType को Scriptable करती हो, जैसे मेनू का कैमरा जो अब भी जुड़ा है।

RoCode से बनाएँ

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

आप लिखते हैं

शुरुआती कटसीन जोड़ो: Intro फ़ोल्डर वाला Cutscenes फ़ोल्डर और 1 से 3 तक शॉट, Caption attribute से कैप्शन, काली पट्टियाँ और Skip बटन, प्लेयर के पहले स्पॉन पर एक बार चले, सर्वर प्लेयर को अपनी जगह रोके, और आख़िर में कैमरा लौटे।

RoCode करता है
  • पहले Search Scripts से आपका place जाँच सकता है, जैसे कोई मेनू या कैमरा स्क्रिप्ट जो पहले से CameraType सेट करती हो, ताकि वे आपस में न टकराएँ
  • Create Instance से फ़ोल्डर और ट्रिगर पार्ट बनाता है और पार्ट पर Caption और MoveSeconds जैसे attribute सेट करता है
  • Create Script से CutsceneService और CutscenePlayer लिखता है
  • उसे हर लिखी स्क्रिप्ट Check Script से जाँचने को कहा गया है, जो उसे बिना चलाए Studio में कंपाइल करता है, और वह बदलावों के हर हिस्से से पहले और बाद undo पॉइंट रखता है

शॉट पार्ट ख़ुद रखें, Studio का कैमरा हर दृश्य पर ले जाकर, और फिर स्क्रिप्ट माँगें। प्लगइन 3.9 या नए के साथ RoCode छोटा playtest चलाकर गलतियाँ पढ़ सकता है, और प्लगइन 3.9.11 या नए के साथ गेम काम करता है यह जाँचने के लिए टेस्ट कैरेक्टर चला सकता है, लेकिन गेम के दौरान वह स्क्रीनशॉट नहीं लेता, इसलिए कटसीन आप ख़ुद देखें। पूरा गेम किस क्रम में बनाना है, यह पेज AI से Roblox गेम कैसे बनाएं, एक-एक सिस्टम करके पर है। RoCode, Studio से कैसे जुड़ता है।

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

गेम में आने पर कटसीन कैसे चलाएँ?

Workspace.Cutscenes में शॉट वाले फ़ोल्डर का नाम Intro रखें, या INTRO_CUTSCENE को अपने फ़ोल्डर के नाम पर बदलें। CutsceneService इसे सर्वर पर हर प्लेयर के पहले स्पॉन पर चलाती है। इसे सिर्फ़ बिल्कुल पहली बार दिखाने के लिए flag को data store में सेव करें और उसे इंट्रो शुरू होने के बाद ही सेट करें, जैसा सिस्टम को आगे कैसे बढ़ाएँ हिस्से में बताया गया है।

क्या बिना प्लगइन के कटसीन बन सकती है?

हाँ। इस गाइड में सिर्फ़ पार्ट, attribute और दो स्क्रिप्ट हैं, और Command Bar वाली लाइन हर शॉट को ठीक वहीं रखती है जहाँ Studio का कैमरा है। कटसीन में अभिनय करने वाले कैरेक्टर ऐनिमेट करने के लिए Moon Animator जैसे प्लगइन फिर भी काम के हैं।

कटसीन में कैमरा क्यों नहीं हिलता?

आम तौर पर कैमरा कोड सर्वर Script में होता है, जबकि प्लेयर का कैमरा सिर्फ़ LocalScript हिला सकता है, क्योंकि हर डिवाइस का अपना कैमरा होता है। दूसरी आम वजह: CameraType Scriptable नहीं है, और Roblox की डिफ़ॉल्ट कैमरा स्क्रिप्ट कैमरे को बार-बार कैरेक्टर पर लौटाती रहती हैं।

कटसीन के दौरान प्लेयर को हिलने से कैसे रोकें?

कटसीन चलते समय सर्वर पर उसका HumanoidRootPart Anchored करें और बाद में हटा दें, जैसा CutsceneService करती है। Anchored पार्ट फ़िज़िक्स से कभी नहीं हिलता। WalkSpeed को छुआ नहीं जाता, इसलिए यह स्प्रिंट स्क्रिप्ट या स्पीड पास से नहीं टकराता।

कटसीन में Skip बटन कैसे जोड़ें?

कटसीन स्क्रीन पर TextButton रखें और उसका Activated इवेंट जोड़ें, जो बटन चुना होने पर क्लिक, टैप या गेमपैड के A बटन पर चलता है। CutscenePlayer का Skip एक फ़्लैग सेट करता है जिसे शॉट वाला लूप हर फ़्रेम जाँचता है, गेमपैड वाले प्लेयर के लिए ख़ुद चुना जाता है, और डिफ़ॉल्ट insets वाले अपने ScreenGui में रहता है, ताकि फ़ोन का कैमरा कटआउट उसे न ढके। कटसीन चलते समय स्टिक और जंप बटन छिपे रहते हैं, इसलिए वे उसके पास नहीं होते।

कटसीन में दुनिया ख़ाली क्यों दिखती है?

instance streaming चालू होने पर प्लेयर के डिवाइस पर सिर्फ़ उसके कैरेक्टर के पास का इलाका होता है। कैमरे के पहुँचने से थोड़ा पहले सर्वर हर शॉट के लिए player:RequestStreamAroundAsync कॉल करे, जैसा CutsceneService करती है। Roblox लिखता है कि इससे इलाका शायद, पर पक्के तौर पर नहीं, लोड होगा, इसलिए ज़रूरी शॉट स्ट्रीमिंग के दायरे में रखें, या उस इलाके के लिए Player:AddReplicationFocus इस्तेमाल करें जिसे लोड रहना है।

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

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

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

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