מדריך · מערכות משחק

איך ליצור סצנה קולנועית ב-Roblox Studio

סצנה קולנועית ב-Roblox היא מצלמה שלוקחת שליטה לכמה שניות: עוברת או טסה בצורה חלקה בין שוטים, מציגה כתובית ומחזירה את השליטה לשחקן. במדריך הזה נבנה סצנה שאתם מגדירים על ידי הצבת Parts בלתי נראים במקומות שבהם המצלמה צריכה לעמוד, בלי פלאגינים. השרת מחליט מתי השחקן רואה אותה (בלידה הראשונה או בנגיעה בטריגר), והמכשיר של השחקן מזיז את המצלמה, מציג פסים שחורים וכפתור Skip ומחזיר את המצלמה.

עודכן 20 בנובמבר 202618 דק׳ קריאהמאת:

בקצרה

הציבו Parts בלתי נראים ומעוגנים בשמות 1, 2, 3 בתיקייה בתוך Workspace.Cutscenes, כל אחד עם הפנים לכיוון שהמצלמה צריכה להסתכל. Script ב-ServerScriptService קורא את ה-CFrame שלהם, מחזיק את השחקן במקום ושולח את השוטים לשחקן הזה דרך RemoteEvent. LocalScript ב-StarterPlayerScripts קובע את workspace.CurrentCamera.CameraType ל-Scriptable, בכל פריים מזיז את המצלמה משוט לשוט (עם החלקה דרך TweenService:GetValue), ואחר כך מחזיר את CameraType ל-Custom ואת CameraSubject ל-Humanoid של השחקן.

  • רק המכשיר של השחקן יכול לשלוט במצלמה, ולכן קוד המצלמה הוא LocalScript. השרת רק מחליט מי רואה איזו סצנה ומתי.
  • כשהמצלמה Scriptable, Roblox מפסיקה לעדכן את Camera.Focus. בתיעוד כתוב לעדכן את Focus בכל פריים, אחרת תאורה דינמית רחוק מהפוקוס הישן עלולה לא להצטייר.
  • Camera:Interpolate מיושן. בתיעוד של 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. מקורות וקריאה נוספת

איך סצנה קולנועית עובדת

איורפתיחה של שני שוטים במהירות אמיתית: מעבר לשוט הראשון, הפסקה של שנייה, טיסה לגשר ב-2.5 שניות, הפסקה של שנייה, ואז המצלמה חוזרת לשחקן.

לכל מכשיר של שחקן יש אובייקט Camera משלו, ב-workspace.CurrentCamera, ולכן רק LocalScript יכול להזיז את מה שהשחקן רואה. להחליט מי רואה איזו סצנה ומתי זו העבודה של השרת. המדריך מחלק את העבודה בדיוק כך. סצנה אחת עוברת כך:

  1. השרת מחליט שהשחקן צריך לראות סצנה: Intro בלידה הראשונה בשרת, או אחרת כשהוא נוגע ב-Part טריגר.
  2. CutsceneService קורא את ה-CFrame וההגדרות של Parts השוטים, מבקש מ-Roblox לטעון לשחקן הזה את האזור של השוט הראשון, מעגן את ה-HumanoidRootPart של השחקן כדי שיעמוד במקום, ושולח את CutsceneEvent רק לשחקן הזה עם id ורשימת שוטים.
  3. CutscenePlayer במכשיר של השחקן מציג פסים שחורים וכפתור Skip, מסתיר את רשימת השחקנים, התרמיל, פס החיים ושליטת המגע, הופך את המצלמה ל-Scriptable ומזיז אותה בכל פריים.
  4. כשהשוט האחרון נגמר או שהשחקן לוחץ על Skip, הוא מחזיר את המצלמה לדמות ושולח לשרת CutsceneEvent עם אותו id.
  5. השרת מסיר את העיגון מהשחקן. אם ההודעה הזו לא הגיעה אף פעם, הוא בכל זאת מסיר את העיגון כשעובר אורך הסצנה ועוד 2 שניות. הטיימר מתחיל כשהשרת שולח את הסצנה, ובכניסה איטית המכשיר יכול להתחיל את הפתיחה כמה שניות מאוחר יותר, כי LocalScript מחוץ ל-ReplicatedFirst לא רץ עד שהמשחק נטען. אז השחקן עלול לזוז שוב לפני שהפתיחה נגמרת אצלו במסך.
ממה מורכבת מערכת הסצנות
רכיבאיפה הוא נמצאמה הוא עושה
Script CutsceneServiceServerScriptServiceמחליט מי רואה איזו סצנה ומתי, קורא את השוטים, מחזיק את השחקן במקום וזוכר מי כבר ראה מה.
LocalScript CutscenePlayerStarterPlayer, StarterPlayerScriptsמנגן את הסצנה במסך של השחקן: פסים, כתוביות, Skip ותנועת מצלמה. בסוף מחזיר את המצלמה.
RemoteEvent CutsceneEventReplicatedStorage (נוצר על ידי CutsceneService)מעביר שוטים מהשרת לשחקן אחד, ובחזרה את ההודעה "הסצנה נגמרה".
Folder CutscenesWorkspaceתיקייה אחת לכל סצנה, למשל Intro, עם Parts של שוטים 1, 2, 3.
Folder CutsceneTriggersWorkspace (לא חובה)Parts שמפעילים סצנה כששחקן נוגע בהם.
ה-Explorer כשמערכת הסצנות מוכנה. התיקיות Bridge ו-CutsceneTriggers מופיעות בשלב 4. כשהמשחק עולה, CutsceneService מוסיף ל-ReplicatedStorage את ה-RemoteEvent בשם CutsceneEvent.
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: הציבו את שוטי המצלמה

כל שוט הוא Part בלתי נראה. המצלמה לוקחת את המיקום של ה-Part ומסתכלת לאותו כיוון כמו הפאה הקדמית שלו, כך שלהציב שוט פירושו להציב מצלמה.

  1. ב-Explorer רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Folder בשם Cutscenes. בתוכו הכניסו Folder בשם Intro. אותיות גדולות וקטנות בשמות חשובות.
  2. הביאו את מצלמת Studio לתצוגה הראשונה שאתם רוצים, כאילו אתם מעמידים פריים לצילום.
  3. הכניסו Part לתוך Intro ושנו את השם שלו ל-1.
  4. פתחו את Command Bar (בלשונית Script או דרך Window, ואז Script) והריצו workspace.Cutscenes.Intro["1"].CFrame = workspace.CurrentCamera.CFrame. במצב עריכה CurrentCamera היא התצוגה שדרכה אתם מסתכלים, ולכן ה-Part נעמד בדיוק בפריים הזה. הסוגריים והמרכאות נחוצים, כי שם שמתחיל בספרה אי אפשר לכתוב אחרי נקודה.
  5. ב-Properties של ה-Part סמנו Anchored, הסירו את הסימון מ-CanCollide, CanTouch ו-CanQuery וקבעו Transparency ל-1. Anchored לא נותן לו ליפול דרך המפה; השאר לא נותנים לו להפריע לשחקנים, להפעיל אירועי נגיעה ולחסום Raycasts.
  6. חזרו על זה לתצוגות הבאות, תוך מתן השמות 2, 3 וכן הלאה ל-Parts ושינוי המספר בשורה ל-Command Bar. CutsceneService מנגן את השוטים לפי סדר המספרים ונעצר במספר החסר הראשון, ולכן חור במספור קוטע את הסצנה מוקדם מדי.

כדי לשנות שוט אחר כך, הביאו את המצלמה לתצוגה החדשה והריצו את אותה שורה עם המספר של השוט הזה. עם Transparency 1 ה-Parts בלתי נראים גם ב-Studio, אז בחרו אותם ב-Explorer כשצריך.

לכל שוט יכולים להיות עוד שלושה Attributes לא חובה. כדי להוסיף Attribute, בחרו את ה-Part, גללו את חלון Properties עד החלק Attributes, לחצו על +, הקלידו שם, בחרו סוג ולחצו על Save.

Attributes לא חובה על כל Part של שוט
Attributeסוגברירת מחדלמה הוא עושה
MoveSecondsnumber3כמה שניות המצלמה טסה מהשוט הקודם לזה. 0 נותן מעבר חד. שוט 1 הוא תמיד מעבר חד, ולכן ה-Attribute לא משפיע עליו.
HoldSecondsnumber1כמה שניות המצלמה עומדת על השוט הזה אחרי שהגיעה.
Captionstringאיןטקסט על הפס התחתון מהרגע שהמצלמה מתחילה לטוס לשוט הזה. שוט בלי Caption מנקה את הטקסט.

מספר שקטן מ-0 או גדול מ-60, וגם Attribute מסוג שגוי, מוחלפים בערך ברירת המחדל.

שלב 2: הוסיפו את סקריפט השרת

רחפו מעל ServerScriptService, הכניסו Script בשם CutsceneService והדביקו בו את הקוד שלמטה. ההגדרות למעלה הן השורות שאתם יכולים לשנות.

Script בתוך ServerScriptService בשם CutsceneService
-- Script ב-ServerScriptService בשם CutsceneService.
-- מחליט מי רואה איזו סצנה ומתי. קורא את שוטי המצלמה מ-Parts ממוספרים
-- ב-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

-- השוטים הם Parts בשמות 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)

-- Parts טריגר: נגיעה מפעילה את הסצנה מה-Attribute בשם Cutscene שלהם
if triggers then
	for _, trigger in triggers:GetChildren() do
		if not trigger:IsA("BasePart") then
			continue
		end
		if not trigger.CanTouch then
			-- חיבור Touched ל-Part עם CanTouch כבוי זורק שגיאה, אז רק מזהירים
			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)

CutsceneService יוצר בעצמו את ה-RemoteEvent בשם CutsceneEvent ברגע ש-Workspace.Cutscenes מופיע, ולכן לא צריך להכניס כלום ביד ל-ReplicatedStorage. אם כבר יצרתם RemoteEvent בשם הזה, מחקו אותו: ה-LocalScript עלול למצוא את שלכם, ואף אחד בשרת לא מאזין לו.

ההגדרות בראש CutsceneService
הגדרההערך כאןמה היא משנה
INTRO_CUTSCENE"Intro"התיקייה ב-Workspace.Cutscenes שמתנגנת בלידה הראשונה של השחקן בשרת. קבעו "" כדי שלא תהיה פתיחה.
DEFAULT_MOVE_SECONDS3כמה זמן נמשכת הטיסה, אם לשוט אין Attribute בשם MoveSeconds.
DEFAULT_HOLD_SECONDS1כמה זמן המצלמה עומדת על השוט, אם אין לו Attribute בשם HoldSeconds.
MAX_SHOTS30מספר השוט הגבוה ביותר ש-CutsceneService מחפש בסצנה אחת.

מה שאר הסקריפט עושה, לפי הסדר:

  • קורא את השוטים בשרת. readShots אוסף לרשימה את ה-CFrame וה-Attributes של כל Part ממוספר. המכשיר של השחקן מקבל את הרשימה הזו, ולכן ה-Parts עצמם לא נחוצים לו.
  • סצנה אחת בכל פעם. play לא עושה כלום בזמן שהשחקן כבר צופה בסצנה, או אם לדמות שלו אין Humanoid או שהיא מתה.
  • לכל סצנה id משלה. המכשיר שולח את ה-id בחזרה כשהסצנה נגמרת או דולגה, ורק id תואם משחרר את השחקן, ולכן הודעה מאוחרת מסצנה קודמת לא יכולה לסיים סצנה חדשה.
  • מחזיק את השחקן במקום על ידי עיגון ה-HumanoidRootPart שלו, ומעגן את הדמות החדשה אם השחקן נולד מחדש באמצע סצנה. בתיעוד של Roblox כתוב ש-Part מעוגן אף פעם לא משנה מיקום בגלל כבידה, התנגשויות או פיזיקה אחרת. ה-WalkSpeed לא נוגעים בו, ולכן זה לא מתנגש עם סקריפט ספרינט או pass למהירות. בסוף הסקריפט מסיר את העיגון מה-root part, גם אם סקריפט אחר עיגן אותו, אז אל תעגנו דמויות במקום אחר בזמן שסצנה עשויה לרוץ.
  • גיבוי. task.delay משחרר את השחקן אחרי האורך המלא של הסצנה ועוד 2 שניות, גם אם המכשיר שלו לא ענה אף פעם.
  • כל סצנה פעם אחת לשרת. הטבלה seen זוכרת לכל שחקן אילו סצנות כבר התחילו, ולכן הפתיחה לא חוזרת בלידה מחדש, וסצנה מטריגר מתנגנת פעם אחת. playOnce מחזיר true רק אם הסצנה באמת התחילה.
  • מגדיר כל שחקן. הלולאה על Players:GetPlayers() בסוף תופסת את כל מי שנכנס בזמן שהסקריפט חיכה לתיקייה Cutscenes.

השוטים נשלחים לשחקן בקריאה אחת ל-FireClient, כרשימה של טבלאות קטנות. בעמוד של Roblox על remote events כתוב לא לשלוח טבלה שמערבבת מפתחות מספריים ומחרוזות; ברשימה הזו יש רק מפתחות מספריים, ובכל שוט בפנים רק מפתחות מחרוזת, וזו הצורה שממליצים עליה שם.

שלב 3: הוסיפו את ה-LocalScript שמנגן אותה

  1. ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts והכניסו LocalScript בשם CutscenePlayer.
  2. החליפו את התוכן שלו בקוד שלמטה.
LocalScript בתוך StarterPlayerScripts בשם CutscenePlayer
-- LocalScript ב-StarterPlayer > StarterPlayerScripts בשם CutscenePlayer.
-- מנגן את הסצנה שהשרת שולח: פסים שחורים, כתוביות, כפתור 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 -- כמה studs לפני המצלמה 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 יש שוליים כברירת מחדל, ולכן החריץ של המצלמה לא מכסה אותו
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

-- רץ בכל פריים בזמן הסצנה. ה-Focus של מצלמת Scriptable לא עוקב בעצמו אחרי
-- שום דבר, ולכן גם אותו קובעים כאן.
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)

LocalScript ב-StarterPlayerScripts מועתק לשחקן פעם אחת, בכניסה, וממשיך לעבוד אחרי לידה מחדש של הדמות. לכן בשני ה-ScreenGui כבוי ResetOnSpawn: אם מפעילים אותו, Roblox תמחק אותם בלידה מחדש הראשונה, והסקריפט הזה לא ייצור אותם מחדש. הודעות remote שהגיעו לפני שהסקריפט התחבר ל-OnClientEvent נכנסות לתור ונמסרות אחרי החיבור, כך ששחקן שנולד מהר עדיין יראה את הפתיחה.

מה עושה כל חלק ב-CutscenePlayer
חלקמה הוא עושה
ScreenGui Cutsceneשני פסים שחורים, כל אחד 12% מגובה המסך (BAR_HEIGHT), וכתובית על הפס התחתון. ScreenInsets None מותח את הפסים עד הקצוות של המסך, ו-DisplayOrder 10 מצייר אותם מעל ScreenGui עם DisplayOrder קטן יותר.
ScreenGui CutsceneControlsיש בו רק את כפתור ה-Skip, מימין על הפס התחתון, עם UISizeConstraint שמחזיק אותו לפחות 64 על 32 פיקסלים, כדי שיהיה קל לפגוע בו בטלפון. יש לו ScreenInsets של ברירת מחדל, והתוכן לא נכנס מתחת לכפתורי הסרגל העליון של Roblox ולחריצי מצלמה. Roblox ממליצה על None רק לתוכן שאין בו מה ללחוץ, ולכן ה-Skip לא יכול לגור ב-ScreenGui עם הפסים.
HIDDEN_CORE_GUISמסתיר את רשימת השחקנים, התרמיל ופס החיים דרך SetCoreGuiEnabled, אחרי שזכר קודם דרך GetCoreGuiEnabled אילו היו מופעלים, ובסוף מפעיל בחזרה רק את אלה שהוא עצמו כיבה. אם המשחק מסתיר את התרמיל במקום אחר, הוא יישאר מוסתר, וסקריפט שמפעיל אותם בזמן הסצנה, למשל תפריט ראשי, אף אחד לא דורס.
TouchControlsEnabledבטלפונים ובטאבלטים play קובע את GuiService.TouchControlsEnabled ל-false לזמן הסצנה. זה מסתיר את הג׳ויסטיק ואת כפתור הקפיצה, שנמצאים בפינות התחתונות, באותו מקום כמו ה-Skip, ובסוף הם חוזרים אם היו מופעלים.
updateCameraרץ בכל פריים בזמן שהסצנה מתנגנת. מחשב איזה חלק מהטיסה הנוכחית עבר, מחליק אותו דרך TweenService:GetValue, מציב את המצלמה בין שני שוטים דרך CFrame:Lerp וקובע את Focus 30 studs לפני המצלמה.
waitOrSkipמחכה לזמן הטיסה ולהפסקה של השוט, ובכל פריים בודק את דגל ה-Skip.
playהופך את המצלמה ל-Scriptable, מנגן את השוטים לפי הסדר, ואז מחזיר את המצלמה (CameraType Custom, CameraSubject הוא ה-Humanoid), מפעיל בחזרה את ה-core GUI ואת שליטת המגע ושולח לשרת את ה-id של הסצנה. אם סצנה שנייה מגיעה בזמן שהראשונה עוד מתנגנת, הוא שולח מיד את ה-id שלה בחזרה, כדי שהשרת לא יחזיק את השחקן במקום בשביל סצנה שהמכשיר הזה לא הציג.
כפתור SkipActivated נורה בלחיצת עכבר, בהקשה או בכפתור A בג׳ויפד כשהכפתור נבחר. לשחקן שהקלט העיקרי שלו הוא ג׳ויפד, play בוחר את Skip בתחילת הסצנה ומבטל את הבחירה בסוף.

שנו את BAR_HEIGHT כדי להפוך את הפסים לדקים או לעבים יותר, ואת EASING_STYLE כדי לשנות את התחושה של הטיסות (ראו מה קוד המצלמה עושה נכון). בכתובית ובכפתור ה-Skip מופעל TextScaled, ולכן הטקסט גדל וקטן יחד עם המסך.

שלב 4: סצנה בנגיעה ב-Part

הפתיחה מתנגנת לבד. לסצנה במקום מסוים במפה, למשל כששחקן מגיע לראשונה לגשר, הוסיפו סצנה שנייה ו-Part טריגר.

  1. ב-Workspace, Cutscenes הכניסו Folder בשם Bridge והציבו את השוטים שלו כמו בשלב 1, בשמות 1 ו-2. בשורה ל-Command Bar כתבו Bridge במקום Intro.
  2. רחפו מעל Workspace והכניסו Folder בשם CutsceneTriggers.
  3. הכניסו לתוכו Part בשם BridgeTrigger. עשו אותו גדול מספיק כדי ששחקנים לא יוכלו לעבור לידו בלי לגעת בו, למשל לוח גבוה ורחב לרוחב הדרך. סמנו Anchored, הסירו את הסימון מ-CanCollide ו-CanQuery, השאירו את CanTouch מסומן וקבעו Transparency ל-1. CanQuery כבוי לא נותן ללוח הבלתי נראה לחסום Raycasts, למשל יריות מהמדריך לנשק. אירועי נגיעה נשלטים דרך CanTouch, לא CanQuery, ולכן הטריגר עדיין עובד.
  4. הוסיפו לו Attribute בשם Cutscene מסוג string וקבעו את הערך Bridge: שם התיקייה שצריך לנגן.

CutsceneService מחבר את Touched לכל Part שנמצא ישירות בתוך CutsceneTriggers כשהשרת עולה, ולכן הוסיפו טריגרים ב-Studio, לא עם סקריפט בזמן המשחק. טריגר עם CanTouch כבוי מדולג עם אזהרה ב-Output, כי Roblox זורקת שגיאה כשסקריפט מחבר Touched ל-Part כזה.

בזמן שדמות עוברת דרך ה-Part, Touched נורה הרבה פעמים ברצף. הטבלה seen והכלל "סצנה אחת בכל פעם" הופכים את זה לסצנה אחת לשחקן לשרת. שחקן שנוגע בטריגר בזמן סצנה אחרת לא נלקח בחשבון, והטריגר נשאר מוכן בשבילו.

אל תשימו טריגרים על כבישים. ה-HumanoidRootPart של שחקן יושב מרותך למושב, וכש-Part אחד בקבוצה מרותכת מעוגן, Roblox מעגנת יחד איתו גם את השאר. לכן שחקן שנוסע לתוך טריגר מחזיק במקום את כל הרכב שלו, יחד עם הנוסעים, עד שהסצנה נגמרת.

מה קוד המצלמה עושה נכון

Scriptable, ואז חזרה ל-Custom

סקריפטי המצלמה של Roblox לא מזיזים ולא מעדכנים את המצלמה כל עוד CameraType שווה Scriptable, ובדיוק זה מה שמאפשר ל-CutscenePlayer להציב אותה. בסוף הוא מחזיר את CameraType ל-Custom והופך את ה-Humanoid של השחקן ל-CameraSubject, שסקריפטי המצלמה של Roblox עוקבים אחריו כברירת מחדל. זה קורה גם אחרי Skip, כך שהשחקן אף פעם לא נשאר להסתכל על השוט האחרון.

שתי בדיקות קטנות שומרות על הסצנה כבוס בזמן שהיא מתנגנת. אם משהו קובע את CameraType לערך אחר באמצע הסצנה, הפונקציה שרצה בכל פריים מחזירה בפריים הבא את Scriptable. ואת workspace.CurrentCamera הסקריפט קורא מחדש בתחילת כל סצנה, כי Roblox יוצרת Camera חדשה אם הנוכחית נמחקת אי פעם.

Focus, בכל פריים

Camera.Focus אומר למנוע לאיזה אזור לתת עדיפות בעבודה כמו תאורה. סקריפטי המצלמה של Roblox מחזיקים אותו על ה-CameraSubject, אבל לא כשהמצלמה Scriptable, ובתיעוד של Roblox כתוב במקרה הזה לעדכן אותו בכל פריים: אור דינמי מאובייקטים כמו PointLight עלול לא להצטייר רחוק מהפוקוס. CutscenePlayer מציב אותו 30 studs לפני המצלמה (FOCUS_DISTANCE). הגדילו את המספר אם השוטים שלכם מסתכלים על משהו רחוק יותר.

הפונקציה רצה דרך RunService:BindToRenderStep, בכל פריים לפני הציור, צעד עדיפות אחד אחרי עדכון המצלמה של Roblox עצמה (Enum.RenderPriority.Camera.Value + 1). את העדיפות הזו משמש מדריך המצלמה של Roblox, ולכן הסצנה מציבה את המצלמה אחרי שקוד המצלמה של Roblox עצמה סיים לרוץ.

החלקה דרך TweenService:GetValue

טווין על camera.CFrame היה מזיז את המצלמה, אבל את Focus בכל זאת צריך לקבוע בכל פריים, ולכן CutscenePlayer מזיז את המצלמה בעצמו באותה פונקציה. לכל טיסה הוא מחשב איזה חלק מהזמן עבר (מ-0 עד 1), מעביר אותו דרך TweenService:GetValue עם סגנון וכיוון ההחלקה, ומציב את המצלמה בחלק הזה של הדרך בין שני שוטים דרך CFrame:Lerp, שמזיז את המיקום בקו ישר ומסובב בצורה חלקה. GetValue מגביל את הקלט בין 0 ל-1, ולכן המצלמה נעצרת בדיוק על השוט כשזמן הטיסה נגמר.

סגנונות החלקה שמתאימים לטיסת מצלמה
EASING_STYLEאיך הטיסה מרגישה
Enum.EasingStyle.Sine (כאן)המהירות הולכת לפי סינוסואידה, התחלה רכה ועצירה רכה.
Enum.EasingStyle.Quadכמו Sine, אבל העקומה מעט חדה יותר.
Enum.EasingStyle.Linearמהירות קבועה, ולכן כל טיסה מתחילה ונגמרת במהירות מלאה.

הכיוון InOut: ההחלקה מוחלת קדימה בחצי הראשון של הטיסה ובכיוון ההפוך בחצי השני, ולכן המצלמה מאיצה משוט אחד ומאטה לקראת הבא.

סטרימינג

בפלייסים חדשים instance streaming מופעל: כברירת מחדל המכשיר של השחקן מחזיק את האזור סביב הדמות שלו, ולכן שוט שמסתכל על הקצה השני של המפה עלול להראות עולם ריק. CutsceneService מבקש מ-Roblox לטעון לשחקן הזה את האזור של כל שוט דרך Player:RequestStreamAroundAsync: את האזור של השוט הראשון לפני שליחת האירוע, עם המתנה של עד 2 שניות, ואת האזור של כל שוט הבא 2 שניות לפני שהמצלמה טסה אליו.

Roblox כותבת שכך האזור כנראה, אבל לא בוודאות, ייטען, ושההשפעה זמנית. השאירו שוטים חשובים בתוך רדיוס הסטרימינג, או השתמשו בשרת ב-Player:AddReplicationFocus לאזור שצריך להישאר טעון עד שתסירו את הפוקוס. כשהסטרימינג כבוי, למכשיר יש ממילא את כל המפה, וה-pcall סביב כל בקשה אומר שבקשה שנכשלה לא יכולה לעצור את הסצנה.

מה לא בסדר במדריכים ישנים לסצנות קולנועיות

אם אתם משווים את המדריך הזה לסרטון או לפוסט בפורום, אלה ההבדלים שחשובים, ולמה כל טריק הוא בעיה.

טריקים נפוצים במדריכים לסצנות ומה המדריך הזה עושה במקומם
מדריךבעיההמדריך הזה
מזיז את המצלמה דרך camera:Interpolate()Roblox סימנה את Interpolate כמיושן וממליצה להנפיש את המצלמה דרך TweenService.מחליק כל טיסה דרך TweenService:GetValue ומציב את המצלמה בכל פריים.
עושה טווין ל-camera.CFrame ולא יותרFocus נשאר איפה שסקריפטי המצלמה השאירו אותו, ליד הדמות, ולכן אור דינמי רחוק ממנו עלול לא להצטייר (התיעוד של Roblox על Camera.Focus).קובע את Focus בכל פריים ב-render step.
לא מחזיר את המצלמההשחקן נתקע ומסתכל על השוט האחרון.בסוף קובע את CameraType ל-Custom ואת CameraSubject ל-Humanoid, וגם אחרי Skip.
מפעיל את הסצנה מ-Touched ב-LocalScriptשום דבר לא מונע ממנה לחזור בכל נגיעה, וההחלטה מתקבלת במכשיר שהשחקן שולט בו.השרת בוחר את השחקן וזוכר מי כבר ראה אותה.
קורא את Parts המצלמה בלקוחכשהסטרימינג מופעל, Parts רחוקים מהדמות עלולים עוד לא להתקיים במכשיר.השרת קורא את ה-Parts, שולח את ה-CFrame שלהם ומבקש את האזור של כל שוט זמן קצר לפני שהמצלמה מגיעה לשם.

מה השחקן יכול ומה הוא לא יכול לשנות

הניחו שרמאי שולט בכל דבר במכשיר שלו: הוא יכול לשנות או למחוק את CutscenePlayer ולשלוח CutsceneEvent עם כל ערך. בשביל סצנה זה כמעט לא משנה, אם שום דבר אמיתי לא תלוי בה.

מה רמאי יכול לנסות ומה ייצא מזה
רמאי מנסהתוצאה
לדלג על הסצנה או בכלל לא לנגן אותהאפשר: זה המסך שלו. אף פעם אל תתנו פרס על "צפה בסצנה עד הסוף".
לשלוח CutsceneEvent עם כל ערךמשהו קורה רק עם מספר שתואם את הסצנה הנוכחית שלו, וכל מה שהוא עושה זה לשחרר אותו מוקדם יותר.
לגעת בטריגר מכל נקודה במפהאפשרי: כל מכשיר שולט בדמות שלו, ובתיעוד האבטחה של Roblox זיוף אירועי Touched מוזכר בין הדברים שהוא יכול לעשות. הוא יראה את הסצנה הזו פעם אחת, ושום דבר נוסף לא יקרה.
לזוז בכל זאת בזמן הסצנהאין מה להרוויח. ההקפאה לא נותנת לשחקנים הגונים ללכת באמצע הסצנה; זו לא בדיקת אבטחה.
להפעיל דרך remote סצנה למישהו אחרבלתי אפשרי. לשלוח CutsceneEvent לשחקן יכול רק השרת, והדבר היחיד שמכשיר יכול לשלוח בחזרה הוא "הסצנה הזו נגמרה".

אם הסצנה מובילה למשהו אמיתי, למשל לדלת שנפתחת אחר כך או להופעה של בוס, תנו לשרת לעשות את זה לפי הטיימר שלו, ולא כשהמכשיר מדווח שהסצנה נגמרה.

שלב 5: בדקו

  1. הציבו שלושה שוטים של Intro עם השורה ל-Command Bar. תנו לשוט 1 Caption "Welcome to the village", לשוט 2 MoveSeconds 2.5 ו-Caption "Find the bridge", והשאירו את שוט 3 בלי Attributes.
  2. לחצו על Play (F5). מופיעים פסים שחורים, המצלמה עוברת לשוט 1 עם הכתובית שלו, תוך 2.5 שניות טסה לשוט 2, ואז תוך 3 שניות לשוט 3 בלי כתובית. אחר כך המצלמה חוזרת מאחורי הדמות, ורשימת השחקנים מופיעה שוב. בזמן שהסצנה מתנגנת אי אפשר ללכת.
  3. עצרו את הבדיקה, לחצו שוב על Play ולחצו על Skip בזמן שהמצלמה טסה לשוט 2. המצלמה חוזרת מיד, ואפשר ללכת מיד.
  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 מדלג על הסצנה. אם אתם משתמשים ב-Device Simulator ב-Studio (נכון לבדיקה שלנו ב-15 באוקטובר 2026 זו בטא: הפעילו אותה ב-File, Beta Features, New Device Simulator והפעילו מחדש את Studio), בחרו טלפון, סובבו אותו לרוחב ובדקו שה-Skip לא נכנס מתחת לחריץ המצלמה וקל לפגוע בו, ושהג׳ויסטיק וכפתור הקפיצה מוסתרים בזמן הסצנה.
  8. אם יצרתם גם תפריט ראשי, לחצו על Play, ואז על כפתור ה-Play בתפריט, ותנו לפתיחה להתנגן עד הסוף: אחריה רשימת השחקנים אמורה להיות שוב במסך.

השאירו את חלון ה-Output פתוח (תפריט Window, ואז Output) כל הזמן. כשהכול עובד, הסקריפטים האלה לא כותבים כלום, כך שכל אזהרה או שגיאה אדומה מ-CutsceneService או מ-CutscenePlayer היא בעיה אמיתית. ראו שגיאות נפוצות.

איך להרחיב את המערכת

פתיחה רק בכניסה הראשונה של השחקן

הטבלה seen חיה בשרת אחד, ולכן שחקן שנכנס מחדש רואה שוב את הפתיחה. כדי להציג אותה רק בכניסה הראשונה, שמרו דגל, למשל SeenIntro, יחד עם שאר הנתונים של השחקן דרך המודול PlayerData מהמדריך ל-DataStore. השאירו את INTRO_CUTSCENE כמו שהוא ושנו את החלק של onCharacterAdded ב-CutsceneService שאחראי על הפתיחה: חכו עד ש-PlayerData.Get(player) יחזיר את נתוני השחקן, דלגו על הפתיחה אם data.SeenIntro שווה true, וקבעו data.SeenIntro = true רק כש-playOnce(player, INTRO_CUTSCENE) החזיר true. אל תפעילו את הפתיחה מהקוד שטוען את הנתונים: הנתונים עלולים להיטען לפני שהדמות נולדת, ובלי דמות play לא עושה כלום, והדגל יישמר לפתיחה שאף אחד לא ראה.

דמויות שמשחקות בסצנה

צרו אנימציה ב-Animation Editor ב-Studio או בפלאגין אנימציה של צד שלישי, למשל Moon Animator, שמוזכר בתיעוד של Roblox, והפעילו אותה על ה-Rig של NPC בשוט כשהמצלמה מגיעה לשם. בתיעוד של Roblox על Animator כתוב שאנימציות של NPC משוכפלות רק אם השרת טוען ומפעיל אותן, ולכן הפעילו אותה מ-Script של שרת אם כל השחקנים צריכים לראות איך ה-NPC משחק. אם טוענים ומפעילים אותה ב-CutscenePlayer, האנימציה לא משוכפלת, וזה מתאים לסצנה שרק שחקן אחד צופה בה. במדריך לסקריפטים של אנימציה מוסבר איך מפעילים אנימציה על NPC מ-Script של שרת.

דיאלוגים

כתוביות מתאימות לשורות קצרות שרצות לבד. לשיחה שבה השחקן עונה ובוחר אפשרויות, ראו את המדריך לדיאלוגים עם NPC.

פתיחה אחרי התפריט הראשי

המדריך לתפריט ראשי מכבה את CharacterAutoLoads, ולכן אף אחד לא נולד עד שהוא לוחץ על Play. CutsceneService מנגן את הפתיחה בלידה הראשונה של השחקן, ולכן עם שתי המערכות הפתיחה מתנגנת בלידה הראשונה אחרי Play. התפריט מפעיל בחזרה את ה-core GUI כשהדמות מופיעה, וזה יכול לקרות כשהפתיחה כבר מתנגנת, ולכן בזמן הפתיחה רשימת השחקנים עלולה להיות גלויה. CutscenePlayer מפעיל בחזרה רק את מה שהוא עצמו הסתיר, ולכן הוא לא נוגע בשינוי של התפריט, ואחרי הפתיחה הם נשארים מופעלים. הטריק עם ה-Command Bar מהמדריך לתפריט ראשי לכיוון Part של מצלמה זהה לזה שבשלב 1.

סיור במפה בתחילת סיבוב

כדי להפעיל סצנה מסקריפט שרת אחר, למשל סיור במפה בתחילת סיבוב מהמדריך למערכת סיבובים, הוסיפו ל-ServerStorage BindableEvent בשם PlayCutscene. בסוף CutsceneService חברו את ה-Event שלו לפונקציה play, ותנו לסקריפט הסיבובים לקרוא לו עם כל שחקן ושם הסצנה. play מדלג על הבדיקה "פעם אחת לשרת", ולכן הסיור מתנגן בכל סיבוב.

פלאגינים לסצנות

אפשר להשתמש בפלאגינים יחד עם המדריך הזה. אם פלאגין לסצנות כותב סקריפט מצלמה משלו, בדקו שהוא מחזיר את המצלמה (CameraType Custom ו-CameraSubject) וקובע את Focus בזמן שהמצלמה Scriptable, ואת ההחלטה מי רואה את הסצנה השאירו בשרת, כמו במדריך הזה.

שגיאות נפוצות ופתרונות

פתחו את חלון ה-Output (תפריט Window, ואז Output) לפני שלוחצים על Play. רוב הבעיות עם סצנות או כותבות שם אזהרה, או נובעות משם שלא תואם.

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

CutsceneService מחכה לתיקייה בשם Cutscenes ישירות ב-Workspace. צרו אותה כמו בשלב 1 ובדקו את האיות ואת ה-C הגדולה. כל עוד היא לא קיימת, CutsceneService לא יוצר את CutsceneEvent, ולכן גם CutscenePlayer מחכה.

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

CutscenePlayer מחכה ל-remote ש-CutsceneService יוצר. בדקו ש-CutsceneService הוא Script, לא LocalScript, נמצא ישירות ב-ServerScriptService, לא מושבת, ושאין ב-Output שגיאה או אזהרה ממנו על Cutscenes.

CutsceneService: no folder named Intro in Workspace.Cutscenes

השם ב-INTRO_CUTSCENE או ב-Attribute בשם Cutscene של הטריגר לא תואם אף תיקייה בתוך Workspace.Cutscenes. אותיות גדולות וקטנות בשמות חשובות.

שום דבר לא מתנגן, וה-Output ריק

בתיקייה אין Part בשם 1, או שה-Parts שלה לא נמצאים ישירות בה (למשל בתוך Model). CutsceneService קורא את ה-Parts 1, 2, 3 לפי הסדר ונעצר במספר החסר הראשון. וזכרו שכל סצנה מתנגנת פעם אחת לשחקן לשרת: עצרו את הבדיקה ולחצו שוב על Play.

המצלמה מסתכלת למקום הלא נכון

המצלמה מסתכלת לאותו כיוון כמו הפאה הקדמית של Part השוט. הביאו את מצלמת Studio לתצוגה הרצויה והריצו שוב את השורה ל-Command Bar משלב 1 עבור השוט הזה.

הטריגר לא עושה כלום

בדקו שה-Part הטריגר נמצא ישירות בתוך Workspace.CutsceneTriggers כשהמשחק עולה, ש-CanTouch מסומן (אחרת תהיה אזהרה ב-Output), ושה-Attribute בשם Cutscene שלו הוא מחרוזת עם שם של תיקייה ב-Workspace.Cutscenes. מעבר חוזר דרך הטריגר לא עושה כלום, וזה מכוון.

אחרי הסצנה המצלמה נשארת על השוט האחרון

CutscenePlayer נעצר עם שגיאה לפני שהספיק להחזיר את המצלמה, אז חפשו ממנו שגיאה אדומה ב-Output. גם סקריפט אחר שכל הזמן קובע את CameraType ל-Scriptable יכול להחזיק את המצלמה, למשל מצלמת תפריט שעדיין מחוברת.

לעשות עם RoCode

אם לא בא לכם לבנות את זה ביד, RoCode יכול לעשות את זה בפלייס שפתוח אצלכם. RoCode הוא סוכן AI עצמאי ל-Roblox Studio, לא של Roblox: אתם מתארים את הפיצ׳ר בצ׳אט שלו באתר, והפלאגין שלו ל-Studio יוצר את ה-Part והסקריפטים ב-Explorer שלכם, כך שלא צריך להעתיק קוד מחלון הצ׳אט.

אתם כותבים

תוסיף סצנת פתיחה: תיקייה Cutscenes עם תיקייה Intro ושוטים 1 עד 3, כתוביות מה-Attribute בשם Caption, פסים שחורים וכפתור Skip, מתנגנת פעם אחת בלידה הראשונה של השחקן, השרת מחזיק את השחקן במקום, ובסוף המצלמה חוזרת.

RoCode עושה
  • יכול קודם לבדוק את הפלייס שלכם עם Search Scripts, למשל אם יש סקריפט תפריט או מצלמה שכבר קובע את CameraType, כדי שלא יתנגשו
  • יוצר את התיקיות ואת ה-Part הטריגר עם Create Instance וקובע על ה-Parts Attributes כמו Caption ו-MoveSeconds
  • כותב את CutsceneService ואת CutscenePlayer עם Create Script
  • הוא מונחה לבדוק כל סקריפט שכתב עם Check Script, שמקמפל אותו ב-Studio בלי להריץ, ומציב נקודת ביטול לפני ואחרי כל קבוצת שינויים

הציבו את Parts השוטים בעצמכם, תוך כיוון מצלמת Studio לכל תצוגה, ואז בקשו את הסקריפטים. עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.11 ומעלה יכול לשלוט בדמות בדיקה כדי לבדוק שהמשחק עובד, אבל בזמן המשחק הוא לא מצלם מסך, ולכן את הסצנה אתם צופים בעצמכם. הסדר שבו בונים משחק שלם נמצא בעמוד איך ליצור משחק ב-Roblox עם AI, מערכת אחר מערכת. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איך גורמים לסצנה להתנגן בכניסה למשחק?

קראו לתיקייה עם השוטים Intro ב-Workspace.Cutscenes, או שנו את INTRO_CUTSCENE לשם התיקייה שלכם. CutsceneService מנגן אותה בלידה הראשונה של כל שחקן בשרת. כדי להציג אותה רק בכניסה הראשונה ממש, שמרו דגל ב-data store וקבעו אותו רק אחרי שהפתיחה התחילה, כמו שמתואר בפרק איך להרחיב את המערכת.

אפשר ליצור סצנה קולנועית בלי פלאגינים?

כן. במדריך הזה יש רק Parts, Attributes ושני סקריפטים, והשורה ל-Command Bar מציבה כל שוט בדיוק במקום שבו עומדת מצלמת Studio. פלאגינים כמו Moon Animator עדיין נוחים כדי להנפיש דמויות שמשחקות בסצנה.

למה המצלמה לא זזה בסצנה?

בדרך כלל קוד המצלמה נמצא ב-Script של שרת, ואת המצלמה של שחקן יכול להזיז רק LocalScript, כי לכל מכשיר יש מצלמה משלו. סיבה נפוצה נוספת: CameraType הוא לא Scriptable, וסקריפטי המצלמה הרגילים של Roblox כל הזמן מחזירים את המצלמה לדמות.

איך מונעים מהשחקן לזוז בזמן סצנה?

עגנו את ה-HumanoidRootPart שלו בשרת בזמן שהיא מתנגנת, והסירו את העיגון אחר כך, כמו ש-CutsceneService עושה. Part מעוגן אף פעם לא זז מהפיזיקה. ה-WalkSpeed לא נוגעים בו, ולכן זה לא מתנגש עם סקריפט ספרינט או עם pass למהירות.

איך מוסיפים כפתור Skip לסצנה?

שימו TextButton במסך הסצנה וחברו את האירוע Activated שלו, שנורה בלחיצה, בהקשה או בכפתור A בג׳ויפד כשהכפתור נבחר. ה-Skip ב-CutscenePlayer מציב דגל שלולאת השוטים בודקת בכל פריים, נבחר לבד לשחקנים עם ג׳ויפד ונמצא ב-ScreenGui משלו עם שוליים של ברירת מחדל, כדי שחריץ המצלמה של הטלפון לא יכסה אותו. הג׳ויסטיק וכפתור הקפיצה מוסתרים בזמן הסצנה, ולכן הם לא עומדים לידו.

למה בסצנה העולם ריק?

כש-instance streaming מופעל, במכשיר של השחקן יש רק את האזור שליד הדמות שלו. תנו לשרת לקרוא ל-player:RequestStreamAroundAsync לכל שוט זמן קצר לפני שהמצלמה מגיעה לשם, כמו ש-CutsceneService עושה. Roblox כותבת שכך האזור כנראה, אבל לא בוודאות, ייטען, ולכן השאירו שוטים חשובים בתוך רדיוס הסטרימינג או השתמשו ב-Player:AddReplicationFocus לאזור שצריך להישאר טעון.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.