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

איך ליצור ריצה על Shift ב-Roblox Studio למחשב, לטלפון ולקונסולה

ריצה על Shift ב-Roblox מסתכמת במספר אחד: ה-WalkSpeed של ה-Humanoid, שעולה כל עוד Shift לחוץ. שלב 1 עושה בדיוק את זה ב-LocalScript קצר אחד, שעובד גם עם כפתור Sprint בטלפון וגם עם ג׳ויפד. שאר המדריך מוסיף את מה שמשחק גדול צריך: פס סיבולת, דאש על הפיזיקה המודרנית, קפיצה כפולה שלא נורית מכפתור לחוץ, והבנה של מה השרת יכול לבדוק ומה לא.

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

בקצרה

שימו LocalScript אחד ב-StarterPlayerScripts, שקושר את הפעולה Sprint דרך ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). כל עוד Shift לחוץ, הוסיפו 10 ל-Humanoid.WalkSpeed (16 הופך ל-26), ובשחרור החזירו את הערך הקודם. הארגומנט true מוסיף כפתור Sprint במסכי מגע, ובסקריפט מהמדריך הזה הכפתור הזה ו-L3 בג׳ויפד מדליקים ומכבים את הריצה, ולא עובדים בהחזקה.

  • הוסיפו ל-WalkSpeed הנוכחי, אל תקבעו 26, כדי שהאצה מ-Game Pass תישמר.
  • הריצה עובדת במכשיר של השחקן. השרת לא יכול לכפות WalkSpeed; הוא יכול רק למדוד כמה רחוק דמויות זזות ולסמן מהירות שריצה לא מסבירה.
  • את פס הסיבולת, הדאש והקפיצה הכפולה על אותו רעיון מוסיפים שלבים 2 עד 4. כמה מהר וכמה זמן לרוץ, יגידו לכם ההגדרות המוכנות לפי סוג משחק, עם מספרים לאימה, לקרב ולעולם פתוח.
בעמוד הזה
  1. איך זה עובד
  2. 1. ריצה על Shift
  3. 2. מודול ההגדרות
  4. 3. ריצה ודאש
  5. 4. קפיצה כפולה
  6. 5. בדיקה בשרת
  7. 6. בדיקה
  8. הגדרות מהירות
  9. סקריפטים ישנים
  10. Input Action System
  11. הרחבות
  12. Common errors
  13. עם RoCode
  14. שאלות נפוצות
  15. מקורות וקריאה נוספת

איך ריצה עובדת ב-Roblox

איורShift נותן ריצה עם WalkSpeed 26 בזמן שהפס מתרוקן, Q עושה דאש ברבע פס, ולחיצה שנייה על קפיצה באוויר קופצת שוב.

המכשיר של כל שחקן מזיז את הדמות שלו עצמו. המקלדת, הבקר או מסך המגע מחליטים לאן הדמות הולכת, ו-Roblox מעבירה את התוצאה לשרת ולכל השאר. לכן ריצה היא LocalScript שמעלה את Humanoid.WalkSpeed כל עוד המקש לחוץ, וזה כל מה ששלב 1 עושה. שאר המדריך הוא מה שמשחק גדול צריך מסביב: פס סיבולת, דאש, קפיצה כפולה ובדיקה בשרת לרמאים.

ממה מורכבת מערכת התנועה
רכיבאיפה הוא נמצאמה הוא עושה
LocalScript ShiftToSprintStarterPlayerScriptsשלב 1 לבד: ריצה במקלדת, בטלפון ובג׳ויפד, בלי סיבולת. כשאתם מוסיפים סיבולת ודאש, MovementClient מחליף אותו.
ModuleScript MovementConfigReplicatedStorageהמספרים: בונוס הריצה, הסיבולת והדאש. גם ה-LocalScript וגם הבדיקה בשרת קוראים אותם.
LocalScript MovementClientStarterPlayerScriptsקושר את Sprint ואת Dash למקש, לכפתור בג׳ויפד ולכפתור מגע, מריץ את לולאת הסיבולת, מצייר את הפס ועושה את הדאש.
LocalScript DoubleJumpStarterCharacterScriptsנותן קפיצה נוספת אחת באוויר. עותק חדש רץ בכל דמות חדשה.
Script MovementCheckServerScriptServiceמודד כמה רחוק כל דמות באמת זזה, וכותב אזהרה ב-Output כשמישהו זז לאורך זמן מהר יותר ממה שהריצה והדאש מאפשרים.
ה-Explorer כשמערכת התנועה מוכנה
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

אם ההבדל בין Script ל-LocalScript חדש לכם, Script, LocalScript ו-ModuleScript מסביר איפה כל סוג רץ ולמה.

שלב 1: ריצה על Shift ב-LocalScript אחד

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

  1. ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts, לחצו על כפתור ה-+ והכניסו LocalScript בשם ShiftToSprint.
  2. החליפו את התוכן שלו בקוד שלמטה ולחצו על Play.
LocalScript בתוך StarterPlayerScripts בשם ShiftToSprint
-- LocalScript ב-StarterPlayer > StarterPlayerScripts בשם ShiftToSprint.
-- החזיקו Left Shift כדי לרוץ. בג׳ויפד לחצו על הסטיק השמאלי (L3) כדי
-- להדליק או לכבות את הריצה. בטלפון לחצו על כפתור Sprint כדי להדליק או לכבות אותה.

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

-- הגדרות
local SPRINT_BONUS = 10 -- מתווסף ל-WalkSpeed בזמן ריצה (16 הופך ל-26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: צריך להחזיק את הכפתור

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- ה-WalkSpeed שאליו צריך לחזור

local function getHumanoid(): Humanoid?
	local character = player.Character
	return character and character:FindFirstChildOfClass("Humanoid")
end

local function setSprinting(on: boolean)
	local humanoid = getHumanoid()
	if not humanoid or on == sprinting then
		return
	end
	sprinting = on
	if on then
		-- זוכרים את המהירות הנוכחית ומוסיפים לה, כדי שהאצה מסקריפט אחר תישמר
		normalSpeed = humanoid.WalkSpeed
		humanoid.WalkSpeed = normalSpeed + SPRINT_BONUS
	else
		humanoid.WalkSpeed = normalSpeed
	end
end

local function onSprint(_name: string, state: Enum.UserInputState, input: InputObject): Enum.ContextActionResult
	local isKeyboard = input.UserInputType == Enum.UserInputType.Keyboard
	if isKeyboard or not TOGGLE_ON_TOUCH_AND_GAMEPAD then
		-- החזקה: ריצה כל עוד המקש או הכפתור לחוצים
		if state == Enum.UserInputState.Begin then
			setSprinting(true)
		elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
			setSprinting(false)
		end
	elseif state == Enum.UserInputState.Begin then
		-- מתג: כל לחיצה מדליקה או מכבה את הריצה
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- קריאה אחת קושרת את המקש, את הכפתור בג׳ויפד, ובמסכי מגע גם כפתור במסך
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- דמות חדשה מתחילה בהליכה: ל-Humanoid שלה כבר יש WalkSpeed רגיל
player.CharacterAdded:Connect(function()
	sprinting = false
end)

שנו את SPRINT_BONUS כדי שהריצה תהיה מהירה או איטית יותר. קבעו את TOGGLE_ON_TOUCH_AND_GAMEPAD ל-false, כדי שהכפתור בטלפון ו-L3 יעבדו כמו Shift: ריצה רק כל עוד לחוץ.

BindAction קושר פעולה אחת ל-Left Shift ולכפתור L3 בג׳ויפד, והארגומנט השלישי שלו, true, מוסיף כפתור במסכי מגע; SetTitle כותב עליו "Sprint". ה-handler מקבל גם את הקלט עצמו, ולכן מבחין בין לחיצה במקלדת לבין ג׳ויפד או כפתור מגע. כשהריצה מתחילה, הסקריפט זוכר את ה-WalkSpeed הנוכחי ומוסיף SPRINT_BONUS; כשהיא נגמרת, הוא מחזיר את הערך שנזכר. מהירות שסקריפט אחר קבע, למשל הטבת Speed מהמדריך ל-Game Passes, נשמרת. דמות חדשה מתחילה עם WalkSpeed רגיל, ולכן ה-handler של CharacterAdded רק מאפס את הדגל.

החזקה או מתג?

איך ShiftToSprint עובד בכל מכשיר כש-TOGGLE_ON_TOUCH_AND_GAMEPAD שווה true
מכשיר וקלטעובד כלמה
מקלדת: Left Shiftהחזקהקל להחזיק מקש בזמן תנועה, ושחרור עוצר מיד את הריצה.
ג׳ויפד: לחיצה על הסטיק השמאלי (L3)מתגלהחזיק את הסטיק לחוץ ובו-זמנית לנווט איתו מעייף.
טלפון או טאבלט: כפתור Sprint במסךמתגאגודל שמחזיק את הכפתור לא יכול באותו זמן ללחוץ על Jump.

כדי לבדוק, לחצו על Play והחזיקו Shift בזמן הליכה: המהירות עולה מ-16 ל-26 studs בשנייה, ואם משחררים, מאטים. לטלפון בחרו טלפון ב-Device Simulator ב-Studio, לחצו על Play ולחצו על Sprint פעם אחת כדי להתחיל, ושוב כדי לעצור. לג׳ויפד פתחו את Controller Emulator בזמן בדיקת משחק ולחצו על L3. רשימת הבדיקות המלאה לפי מכשירים נמצאת בשלב 6.

שלבים 2 ו-3 מחליפים את הסקריפט הזה בסקריפט אחר, עם פס סיבולת ודאש. שלבים 4 ו-5 מוסיפים קפיצה כפולה ובדיקה בשרת, ועובדים עם כל אחד משני הסקריפטים.

שלב 2: המספרים של הסיבולת והדאש במודול אחד

לריצה שנגמרת, שלבים 2 ו-3 מחליפים את ShiftToSprint ב-LocalScript גדול יותר עם פס סיבולת ודאש. קודם מחקו את ShiftToSprint: שני הסקריפטים קושרים את הפעולה Sprint.

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

  1. ב-Explorer רחפו מעל ReplicatedStorage, לחצו על כפתור ה-+ והכניסו ModuleScript.
  2. שנו את השם שלו ל-MovementConfig והחליפו את התוכן בקוד שלמטה.
ModuleScript בתוך ReplicatedStorage בשם MovementConfig
-- סט מספרים אחד ל-LocalScript של התנועה ולבדיקת המהירות בשרת.

local MovementConfig = {
	SPRINT_BONUS = 10, -- מתווסף ל-WalkSpeed הנוכחי: 16 (ערך ברירת המחדל של Roblox) הופך ל-26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 שניות ריצה מפס מלא
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- שניות אחרי סוף הריצה, לפני שהסיבולת מתחילה להתחדש
	MIN_TO_START = 20, -- סיבולת שנדרשת כדי להתחיל לרוץ, כדי שפס ריק לא יהבהב

	DASH_SPEED = 60, -- studs בשנייה בזמן דאש
	DASH_SECONDS = 0.2, -- כך הדאש עובר בערך 12 studs
	DASH_COST = 25, -- סיבולת
	DASH_COOLDOWN = 1,
}

return MovementConfig
מה כל הגדרה עושה
הגדרהערךהשפעה
SPRINT_BONUS10מתווסף ל-WalkSpeed בזמן ריצה. ה-WalkSpeed ב-Roblox כברירת מחדל הוא 16, ולכן הריצה היא במהירות 26 studs בשנייה.
MAX_STAMINA100פס מלא.
DRAIN_PER_SECOND20פס מלא מספיק ל-5 שניות ריצה.
REGEN_PER_SECOND15פס ריק מתמלא בערך תוך 6.7 שניות.
REGEN_DELAY1שניות מנוחה לפני תחילת ההתחדשות.
MIN_TO_START20סיבולת שנדרשת כדי להתחיל לרוץ.
DASH_SPEED60studs בשנייה בזמן דאש.
DASH_SECONDS0.2כמה זמן הדאש נמשך: בערך 12 studs ב-60 studs בשנייה.
DASH_COST25סיבולת לכל דאש.
DASH_COOLDOWN1שניות בין דאשים.

כל צד מריץ עותק משלו של המודול (מודול רץ פעם אחת בכל צד), ולכן שחקן שמשנה את המספרים האלה במכשיר שלו משנה רק את העותק שלו. אבל כאן זה לא מגן על כלום: המכשיר שלו ממילא מזיז את הדמות שלו, ולכן הוא יכול לתת לעצמו סיבולת אינסופית, מה שלא יהיה במודול. הבדיקה בשרת משלב 5 בנויה בהתחשב בזה.

שלב 3: ריצה עם סיבולת ודאש

ה-LocalScript הזה עושה את מה ששחקנים מרגישים. הוא קושר את Sprint ואת Dash, מצייר את פס הסיבולת, מריץ בכל פריים את לולאת הסיבולת ועושה את הדאש.

  1. ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterPlayerScripts והכניסו LocalScript בשם MovementClient.
  2. החליפו את התוכן שלו בקוד שלמטה.
LocalScript בתוך StarterPlayerScripts בשם MovementClient
-- החזיקו Shift (או L3, או כפתור Sprint בטלפון) כדי לרוץ, כל עוד יש סיבולת.
-- לחצו על Q (או B, או כפתור Dash) כדי לעשות דאש לכיוון התנועה.

local ContextActionService = game:GetService("ContextActionService")
local Debris = game:GetService("Debris")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

type Config = {
	SPRINT_BONUS: number,
	MAX_STAMINA: number,
	DRAIN_PER_SECOND: number,
	REGEN_PER_SECOND: number,
	REGEN_DELAY: number,
	MIN_TO_START: number,
	DASH_SPEED: number,
	DASH_SECONDS: number,
	DASH_COST: number,
	DASH_COOLDOWN: number,
}
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config

local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- ה-WalkSpeed שאליו חוזרים כשהריצה נגמרת
local lastSprintTime = 0
local lastDashTime = -math.huge

-- פס הסיבולת: מסגרת עם מילוי, שהרוחב שלו שווה לסיבולת שנשארה
local gui = Instance.new("ScreenGui")
gui.Name = "StaminaGui"
gui.ResetOnSpawn = false
local bar = Instance.new("Frame")
bar.AnchorPoint = Vector2.new(0.5, 1)
bar.Position = UDim2.new(0.5, 0, 1, -24)
bar.Size = UDim2.fromOffset(240, 14)
bar.BackgroundColor3 = Color3.fromRGB(30, 26, 40)
bar.Parent = gui
local fill = Instance.new("Frame")
fill.Size = UDim2.fromScale(1, 1)
fill.BackgroundColor3 = Color3.fromRGB(80, 220, 150)
fill.BorderSizePixel = 0
fill.Parent = bar
for _, frame in { bar, fill } do
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(1, 0)
	corner.Parent = frame
end
gui.Parent = player:WaitForChild("PlayerGui")

local function getHumanoid(): Humanoid?
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid and humanoid.Health > 0 then
		return humanoid
	end
	return nil
end

-- ריצה: כאן רק דגל; לולאת ה-Heartbeat שלמטה מחליטה בכל פריים אם לרוץ
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- רק לחיצה ושחרור משנים אותו: אצבע שמחליקה על כפתור מגע שולחת Change
	if state == Enum.UserInputState.Begin then
		sprintHeld = true
	elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
		sprintHeld = false
	end
	return Enum.ContextActionResult.Pass
end

local function dash()
	local humanoid = getHumanoid()
	local rootPart = humanoid and humanoid.RootPart
	local now = os.clock()
	-- בישיבה אין דאש: דמות יושבת מרותכת למושב, ולכן הייתה דוחפת את כל הרכב
	if not (humanoid and rootPart) or humanoid.Sit or now - lastDashTime < Config.DASH_COOLDOWN or stamina < Config.DASH_COST then
		return
	end
	local attachment = rootPart:FindFirstChild("RootAttachment")
	if not (attachment and attachment:IsA("Attachment")) then
		return
	end
	lastDashTime = now
	stamina -= Config.DASH_COST
	lastSprintTime = now -- משהים את ההתחדשות, כמו שהריצה עושה

	-- דאש לכיוון שהשחקן זז, או לכיוון שהוא מסתכל אם הוא עומד במקום
	local direction = humanoid.MoveDirection
	if direction.Magnitude < 0.1 then
		direction = rootPart.CFrame.LookVector
	end
	direction = Vector3.new(direction.X, 0, direction.Z).Unit

	-- LinearVelocity במצב Plane מחזיק מהירות אופקית ולא מפריע לכבידה
	local velocity = Instance.new("LinearVelocity")
	velocity.Attachment0 = attachment
	velocity.RelativeTo = Enum.ActuatorRelativeTo.World
	velocity.VelocityConstraintMode = Enum.VelocityConstraintMode.Plane
	velocity.PrimaryTangentAxis = Vector3.xAxis
	velocity.SecondaryTangentAxis = Vector3.zAxis
	velocity.PlaneVelocity = Vector2.new(direction.X, direction.Z) * Config.DASH_SPEED
	velocity.MaxForce = math.huge
	velocity.Parent = rootPart
	Debris:AddItem(velocity, Config.DASH_SECONDS)
end

local function onDash(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	if state == Enum.UserInputState.Begin then
		dash()
	end
	return Enum.ContextActionResult.Pass
end

-- כל קריאה קושרת מקש, כפתור בג׳ויפד, ובמכשירי מגע גם כפתור במסך
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:BindAction("Dash", onDash, true, Enum.KeyCode.Q, Enum.KeyCode.ButtonB)
ContextActionService:SetTitle("Sprint", "Sprint")
ContextActionService:SetTitle("Dash", "Dash")

-- בכל פריים: מוציאים סיבולת בזמן ריצה ותנועה, משחזרים אחרי מנוחה קצרה
RunService.Heartbeat:Connect(function(deltaTime: number)
	local humanoid = getHumanoid()
	if not humanoid then
		return
	end
	local moving = humanoid.MoveDirection.Magnitude > 0
	local now = os.clock()
	local enoughStamina = if sprinting then stamina > 0 else stamina >= Config.MIN_TO_START
	local shouldSprint = sprintHeld and moving and enoughStamina

	-- משנים את WalkSpeed רק בתחילת הריצה ובסופה, כדי שמהירות שקבע
	-- סקריפט אחר (למשל pass למהירות) תישמר, והריצה תתווסף אליה
	if shouldSprint and not sprinting then
		sprinting = true
		normalSpeed = humanoid.WalkSpeed
		humanoid.WalkSpeed = normalSpeed + Config.SPRINT_BONUS
	elseif not shouldSprint and sprinting then
		sprinting = false
		humanoid.WalkSpeed = normalSpeed
	end

	if sprinting then
		stamina = math.max(0, stamina - Config.DRAIN_PER_SECOND * deltaTime)
		lastSprintTime = now
	elseif now - lastSprintTime >= Config.REGEN_DELAY then
		stamina = math.min(Config.MAX_STAMINA, stamina + Config.REGEN_PER_SECOND * deltaTime)
	end
	fill.Size = UDim2.fromScale(stamina / Config.MAX_STAMINA, 1)
end)

-- דמות חדשה מתחילה עם סיבולת מלאה ובלי שום דבר לחוץ
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- Humanoid חדש מתחיל עם WalkSpeed רגיל
end)

פס הסיבולת נוצר בקוד עם ResetOnSpawn ששווה false, ולכן הוא נשאר במסך אחרי לידה מחדש, וה-handler של CharacterAdded שלמטה ממלא אותו מחדש לכל דמות חדשה. שורות ה-type Config מתארות מה המודול מחזיר, כדי שבדיקת הטיפוסים המחמירה תתפוס שגיאת הקלדה בשם של הגדרה; בזמן המשחק הן לא משנות כלום.

מקלדת, ג׳ויפד וכפתור בטלפון בקריאה אחת

ContextActionService:BindAction מקבל שם פעולה, פונקציית handler, האם ליצור כפתור מגע, ואז את הקלטים. אם מעבירים true כארגומנט שלישי, ContextActionService מוסיף כפתור למסך במכשירי מגע, בתוך ScreenGui בשם ContextActionGui ב-PlayerGui של השחקן. SetTitle כותב על הכפתורים האלה "Sprint" ו-"Dash". BindAction יכול ליצור לא יותר מ-7 כפתורי מגע, אז שימו לב לכמות אם גם סקריפטים אחרים במשחק משתמשים בהם.

ה-handler מקבל את מצב הקלט: Begin בלחיצה ו-End בשחרור. onSprint רק זוכר אם Sprint לחוץ. הוא מחשיב כשחרור גם את Cancel, ש-ContextActionService שולח כשקישור אחר לוקח את הקלט, ומתעלם מ-Change, שאצבע שזזה על כפתור מגע יכולה לשלוח. שני ה-handlers מחזירים Pass, ולכן הקישור הבא על אותו מקש מקבל גם הוא את הקלט.

התיעוד של Roblox על ContextActionService ממליץ עליו במקום UserInputService.InputBegan ברוב המקרים. הדוגמה שלו: צופר של מכונית על H, שלא אמור לצפור בזמן שהשחקן כותב בצ׳אט. קישור נורה רק כל עוד הוא האחרון לקלט הזה, ולכן כשהצ׳אט לוקח את המקלדת, לא צריך לבדוק כלום. קלטי הג׳ויפד: ButtonL3 (לחיצה על הסטיק השמאלי, שמחזיקים בזמן תנועה) ו-ButtonB. בדוגמת הריצה של Roblox עצמה משתמשים ב-ButtonY, אז שנו את ה-KeyCode ב-BindAction אם זה נוח יותר למשחק שלכם.

לולאת הסיבולת

RunService.Heartbeat נורה בכל פריים אחרי צעד הפיזיקה ומעביר deltaTime, מספר השניות מאז הפריים הקודם. אם מכפילים בו את קצב ההוצאה וההתחדשות, פס מלא יספיק ל-5 שניות, בין אם המשחק רץ ב-30 ובין אם ב-240 פריימים בשנייה.

בכל פריים הלולאה מחליטה אם הדמות צריכה לרוץ: Sprint לחוץ, הדמות הולכת (Humanoid.MoveDirection שווה לווקטור אפס כשהיא עומדת), ועוד יש סיבולת. כדי להתחיל לרוץ צריך לפחות MIN_TO_START (20); כדי להמשיך, מספיק כל דבר מעל 0. בלי הפער הזה, פס ריק שמתמלא קצת בכל פריים היה מדליק ומכבה את הריצה בכל פריים. ההתחדשות מתחילה REGEN_DELAY (שנייה אחת) אחרי הריצה או הדאש האחרונים, ולכן אחרי שרוקנו את הפס, השחקן מחכה בערך 2.3 שניות לפני שהוא יכול לרוץ שוב.

WalkSpeed משתנה רק בפריים שבו הריצה מתחילה או נגמרת. בהתחלה הסקריפט זוכר את ה-WalkSpeed הנוכחי ומוסיף SPRINT_BONUS; בסוף הוא מחזיר את הערך שנזכר. לכן מהירות שסקריפט אחר קבע נשמרת: הטבת Speed מהמדריך ל-Game Passes קובעת WalkSpeed 24, ועם הסקריפט הזה הבעלים שלה רצים ב-34. סקריפט שכותב WalkSpeed = 16 בכל פריים או בכל שחרור היה מבטל בשקט את ההטבה הזו.

הדאש

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

הדחיפה היא אילוץ LinearVelocity על ה-RootAttachment של ה-Part הראשי. במצב Plane עם הצירים X ו-Z הוא מחזיק מהירות אופקית של 60 studs בשנייה ולא נוגע באנך, ולכן הכבידה עובדת, ודאש ממדף נופל כרגיל. MaxForce שווה math.huge, כך שהדחיפה לא מוגבלת בכלום. Debris:AddItem משמיד את האילוץ אחרי DASH_SECONDS בלי לגרום לסקריפט לחכות, ולכן הדאש נמשך 0.2 שנייה, בערך 12 studs במהירות הזו.

מדריכים ישנים משתמשים ב-BodyVelocity, ש-Roblox סימנה כמיושן עם הערה להשתמש במקומו ב-LinearVelocity. את הטריק שלו עם MaxForce אפס בציר אחד מחליפים המצבים Line, Plane ו-Vector של LinearVelocity. מכיוון שהמכשיר של השחקן מדמה בעצמו את הדמות שלו, אילוץ ש-LocalScript יצר מזיז אותה, ושחקנים אחרים רואים את הדאש כמו כל תנועה אחרת.

המדריך של Roblox עצמה ל-UI מחבר את האילוץ ל-humanoid.RootPart.RootAttachment בדיוק באותה דרך. אם במשחק שלכם יש דמות משלכם, שב-Part הראשי שלה אין Attachment בשם RootAttachment, הדאש לא עושה כלום: הוסיפו אותו ל-HumanoidRootPart של ה-StarterCharacter שלכם.

שלב 4: קפיצה כפולה

הקפיצה הכפולה חיה ב-LocalScript משלה ב-StarterCharacterScripts. Roblox שמה עותק של הסקריפטים מהמכל הזה בכל דמות בלידה, והעותקים האלה לא שורדים לידה מחדש, ולכן כל חיים מתחילים מסקריפט טרי, ושום דבר לא עובר מהקודמים.

  1. ב-Explorer פתחו את StarterPlayer, רחפו מעל StarterCharacterScripts והכניסו LocalScript בשם DoubleJump.
  2. החליפו את התוכן שלו בקוד שלמטה.
LocalScript בתוך StarterCharacterScripts בשם DoubleJump
-- נותן קפיצה נוספת אחת באוויר. רץ מחדש לכל דמות חדשה,
-- ולכן אחרי לידה מחדש שום דבר לא עובר.

local UserInputService = game:GetService("UserInputService")

local character = script.Parent :: Model
local humanoid = character:WaitForChild("Humanoid") :: Humanoid

local EXTRA_JUMPS = 1
local MIN_SECONDS_BETWEEN_JUMPS = 0.25 -- JumpRequest נורה כמה פעמים בלחיצה אחת
local NEW_PRESS_GAP = 0.1 -- כפתור קפיצה לחוץ ממשיך לשלוח JumpRequest; הפסקה באורך כזה אומרת ששחררו אותו

local jumpsLeft = 0
local lastJump = 0
local lastRequest = 0

humanoid.StateChanged:Connect(function(oldState: Enum.HumanoidStateType, newState: Enum.HumanoidStateType)
	if newState == Enum.HumanoidStateType.Jumping and oldState ~= Enum.HumanoidStateType.Freefall then
		-- קפיצה מהקרקע (לא אחת מהקפיצות שלנו באוויר) משחזרת את הקפיצות באוויר
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest נורה כשהשחקן מבקש קפיצה, למשל דרך Space או כפתור הקפיצה בטלפון
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- רק לחיצה חדשה קופצת שוב, כדי שכפתור לחוץ לא יבזבז קפיצה באוויר
	if not newPress or jumpsLeft <= 0 or now - lastJump < MIN_SECONDS_BETWEEN_JUMPS then
		return
	end
	if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
		jumpsLeft -= 1
		lastJump = now
		humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
	end
end)

קבעו EXTRA_JUMPS ל-2 לקפיצה משולשת.

הסקריפט עוקב אחרי מצב הדמות דרך Humanoid.StateChanged. מעבר ל-Jumping שלא הגיע מ-Freefall הוא קפיצה מהקרקע, ולכן הוא נותן קפיצה באוויר, ו-Landed לוקח אותה שוב. אם יורדים ממדף, הדמות נכנסת ל-Freefall בלי קפיצה, ולכן לא מקבלת קפיצה באוויר. אם צריך אותה גם שם, קבעו את jumpsLeft גם במעבר ל-Freefall מכל מצב חוץ מ-Jumping.

UserInputService.JumpRequest נורה כשהשחקן מבקש קפיצה, למשל דרך Space או כפתור הקפיצה בטלפון. התיעוד של Roblox מזהיר שהוא נורה כמה פעמים לבקשת קפיצה אחת וממליץ על debounce, ולכן הסקריפט מתעלם מבקשות במשך 0.25 שנייה אחרי הקפיצה האחרונה. גם כפתור קפיצה לחוץ יכול להמשיך לבקש קפיצות, והיה מבזבז את הקפיצה באוויר ברגע שהדמות מתנתקת מהקרקע, ולכן בקשה נחשבת ללחיצה חדשה רק אחרי 0.1 שנייה בלי בקשות.

הקפיצה באוויר עצמה היא Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). התיעוד של Roblox אומר שצריך לקרוא לה מ-LocalScript במכשיר שיש לו בעלות ברשת על הדמות, וכברירת מחדל זה המכשיר של השחקן עצמו, לא השרת. דוגמת הקוד ל-ChangeState בתיעוד היא בדיוק קפיצה כפולה.

שלב 5: תופסים speedhack בשרת

מדריכים לריצה נעצרים לעיתים קרובות בלקוח. Script של שרת לא יכול לסמוך על ה-WalkSpeed של שחקן, כי אקספלויטרים משנים אותו במכשיר שלהם, אבל הוא רואה איפה הדמות שלהם נמצאת. MovementCheck מודד את זה פעמיים בשנייה וכותב אזהרה ב-Output כשמישהו זז לאורך זמן מהר יותר ממה שהריצה והדאש מאפשרים. את המספרים של הריצה והדאש הוא קורא מ-MovementConfig, אז הוסיפו את המודול הזה משלב 2, גם אם השארתם את ShiftToSprint.

  1. רחפו מעל ServerScriptService והכניסו Script בשם MovementCheck.
  2. החליפו את התוכן שלו בקוד שלמטה.
Script בתוך ServerScriptService בשם MovementCheck
-- מכשירי השחקנים מזיזים את הדמויות שלהם, ולכן אקספלויטר יכול לקבוע כל WalkSpeed.
-- הבדיקה הזו מודדת כמה רחוק כל דמות באמת זזה, וכותבת ב-Output
-- כשמישהו זז לאורך זמן מהר יותר ממה שהריצה והדאש מאפשרים. היא רק מזהירה:
-- lag, טלפורטים ומסועים יכולים להיראות כמו חריגה ממהירות, אז כווננו אותה לפני שמענישים מישהו.

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

type Config = { SPRINT_BONUS: number, DASH_SPEED: number, DASH_SECONDS: number }
local Config = require(ReplicatedStorage:WaitForChild("MovementConfig")) :: Config

local CHECK_EVERY = 0.5 -- שניות
-- מהירות הריצה ועוד מרווח ל-lag. הגדילו אם אתם מוכרים האצות.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- מרווח לדאש אחד או שניים
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- כמה מהר דאשים קודמים נסלחים

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- ה-Part הראשי שעליו נמדד lastPosition
local excess: { [Player]: number } = {} -- studs מעבר לסובלנות, נסלחים בהדרגה

Players.PlayerRemoving:Connect(function(player: Player)
	lastPosition[player] = nil
	lastRoot[player] = nil
	excess[player] = nil
end)

while true do
	task.wait(CHECK_EVERY)
	for _, player in Players:GetPlayers() do
		local character = player.Character
		local rootPart = character and character:FindFirstChild("HumanoidRootPart")
		if rootPart and rootPart:IsA("BasePart") then
			local position = rootPart.Position
			-- לידה מחדש היא Part ראשי חדש, וטלפורט בשרת (תחילת סיבוב, צ׳קפוינט)
			-- קובע את ה-Attribute שלמטה: מתחילים למדוד מחדש, ולא מסמנים קפיצה
			local previous = if lastRoot[player] == rootPart then lastPosition[player] else nil
			if player:GetAttribute("MovementCheckSkip") then
				player:SetAttribute("MovementCheckSkip", nil)
				previous = nil
			end
			lastPosition[player] = position
			lastRoot[player] = rootPart
			if previous then
				-- רק תנועה אופקית: ליפול מהר זו לא רמאות
				local moved = Vector3.new(position.X - previous.X, 0, position.Z - previous.Z).Magnitude
				local extra = moved - SPEED_ALLOWANCE * CHECK_EVERY
				local total = math.max(0, (excess[player] or 0) + extra - DRAIN_PER_CHECK)
				excess[player] = total
				if total > BURST_ALLOWANCE then
					warn(`MovementCheck: {player.Name} moved {math.round(moved / CHECK_EVERY)} studs/s`)
					excess[player] = 0
				end
			end
		else
			lastPosition[player] = nil
			lastRoot[player] = nil
		end
	end
end

האזהרה מופיעה ב-Output ב-Studio. במשחק חי היא נכנסת ללוג השרת של Developer Console, שאתם יכולים לקרוא כבעלי המשחק: ראו פלט במשחק חי.

מה היא מודדת

כל חצי שנייה הסקריפט קורא את המיקום של ה-Part הראשי של כל דמות, ומודד כמה הוא זז אופקית מאז הבדיקה הקודמת. הגובה לא נלקח בחשבון, ולכן נפילות וקפיצות אף פעם לא נספרות; העצה של Roblox לבדיקת תנועה מציעה את אותה הטלה על מישור XZ למשחקים שבהם הולכים על הקרקע. הסובלנות היא מהירות ההליכה כברירת מחדל, ועוד בונוס הריצה, ועוד רבע ל-lag: 32.5 studs בשנייה. מרחק מעבר לזה נכנס ל"דלי דולף", צובר שעליו כתוב בתיעוד של Roblox שהוא מתאים להרבה מפתחים להתפרצויות קצרות. הדלי מאבד 3 studs בכל בדיקה, והסקריפט מזהיר כשיש בו יותר מ-24 studs, מרווח של בערך שני דאשים.

מה הבדיקה תופסת, אם מחשבים לפי המספרים שלה
רמאימה MovementCheck עושה
קובע WalkSpeed 100מזהיר אחרי בערך שנייה של ריצה
קובע WalkSpeed 50מזהיר אחרי בערך 2.5 שניות של ריצה
עושה דאשים ברצף בלי זמן המתנה (60 studs בשנייה)מזהיר אחרי בערך 1.5 שניות
משתגר יותר מ-43 studs בבת אחתמזהיר בבדיקה הבאה
רץ במהירות של עד 38 studs בשנייה, בערך פי אחד וחצי ממהירות הריצהכלום: מתחת ל-38.5 studs בשנייה הדלי מתרוקן באותה מהירות שהוא מתמלא
משנה את ה-MovementConfig שלו בשביל סיבולת אינסופיתכלום: ריצה ב-26 studs בשנייה מותרת כמה זמן שרוצים
עף, קופץ בלי הגבלה או עובר דרך קירותכלום: הבדיקה מתעלמת מגובה ולא מסתכלת על התנגשויות

כלומר, הבדיקה תופסת רמאויות גסות, שבהן השחקן מהיר בבירור מכל השאר, ומפספסת עדינות. זה הגבול הכן של בדיקה לפי מרחק, והסיבה ש-Roblox עושה משהו חזק יותר (ראו server authority למטה).

למה היא רק מזהירה

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

לידות מחדש וטלפורטים

לידה מחדש יוצרת Part ראשי חדש, והסקריפט מתחיל למדוד מחדש כשהוא רואה אותו, ולכן מוות רחוק מנקודת הלידה אף פעם לא נחשב כחריגה ממהירות. טלפורטים שסקריפטי השרת שלכם עושים צריכים חריגה, כמו שכתוב בתיעוד של Roblox לכל משחק עם טלפורטים. אחרי טלפורט הוסיפו player:SetAttribute("MovementCheckSkip", true), והבדיקה הבאה תתחיל למדוד מהמיקום החדש, ולא תסמן קפיצה:

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

נחשב רק הערך מהשרת. Attribute ששחקן קובע במכשיר שלו נשאר במכשיר הזה (ראו מה משוכפל ומה לא), ולכן רמאי לא יכול לכבות בו את הבדיקה.

פתרון לעתיד: server authority

תיעוד האבטחה של Roblox מכנה את מודל ה-server authority, נכון לזמן הכתיבה בבטא, הדרך האמינה ביותר לעצור אקספלויטים של תנועה. מקור האמת הופך לשרת, ומכשירי השחקנים רק מדווחים על הקלט שלהם, מה שלפי התיעוד מונע מ-speedhacks לעבוד, כי אף פעם לא סומכים על המכשיר שידווח על המיקום שלו עצמו.

המעבר הוא שכתוב, לא כוונון. במודל הזה את התנועה מחשב השרת, ולכן WalkSpeed או LinearVelocity שרק LocalScript קובע מתבטלים כשמגיע המצב מהשרת. בתיעוד של Roblox כתוב שהלוגיקה העיקרית צריכה לרוץ בפונקציות RunService:BindToSimulation() ב-ModuleScript שגם הלקוח וגם השרת מריצים. המודל צריך גם כמה הגדרות של Workspace, כולל PlayerScriptsUseInputActionSystem, כך שגם השליטה שלכם תעבור ל-Input Action System. השאירו את הגרסה מהמדריך הזה עד שתעבירו את הריצה, הסיבולת והדאש למבנה הזה. עד אז, בדיקה לפי מרחק כמו זו היא בדיוק מה שהפרק של Roblox על בדיקת תנועה מתאר.

שלב 6: בדקו בכל מכשיר

  1. לחצו על Play והחזיקו Shift בזמן הליכה. המהירות עולה מ-16 ל-26 studs בשנייה, והפס הירוק בתחתית המסך מתקצר. אחרי בערך 5 שניות הוא ריק, ואתם שוב הולכים.
  2. שחררו את Shift. אחרי שנייה אחת הפס מתחיל להתמלא. עד שהוא מתמלא לחמישית, Shift לא עושה כלום.
  3. לחצו על Q בזמן הליכה: אתם נזרקים קצת קדימה, ורבע מהפס נעלם. לחצו מיד שוב על Q, ושום דבר לא יקרה עד שתעבור שנייה. אם הדאש מרגיש קצר או ארוך מדי, שנו את DASH_SPEED או את DASH_SECONDS ב-MovementConfig.
  4. קפצו, ואז לחצו שוב על קפיצה באוויר לקפיצה שנייה. נחתו ונסו שוב: כל קפיצה מהקרקע מחזירה את הקפיצה באוויר.
  5. החזיקו Space לחוץ לאורך כל הקפיצה. אמורה לצאת קפיצה אחת, לא שתיים, כי קפיצה באוויר צריכה לחיצה חדשה.
  6. הפעילו את Device Simulator ב-Studio (נכון לזמן הכתיבה זו בטא: File, Beta Features, New Device Simulator, ואז הפעילו מחדש את Studio), או הפעילו את ה-Device Emulator הישן בתפריט Test. בחרו טלפון ולחצו על Play. יופיעו הכפתורים Sprint ו-Dash. החזיקו Sprint בזמן שאתם מנווטים, ואז החזיקו את כפתור הקפיצה לאורך כל הקפיצה ובדקו שיש רק קפיצה אחת.
  7. פתחו את Controller Emulator (Controller בלשונית Emulation, או Virtual controller בחלונית Device Simulator). החזיקו L3 בזמן תנועה כדי לרוץ, לחצו על B לדאש ועל A פעמיים לקפיצה כפולה.
  8. אפסו את הדמות דרך תפריט המשחק. הפס שוב מלא, ב-Output אין אזהרה של MovementCheck, ואם אתם עדיין מדמים טלפון, הכפתורים Sprint ו-Dash במקום.
  9. עכשיו שחקו כרמאי. לחצו על המתג Client/Server עד שה-Explorer יציג את הלקוח, סמנו את ה-Humanoid של הדמות שלכם ב-Workspace וקבעו WalkSpeed ל-60 בחלון Properties. הסתובבו כמה שניות: ב-Output תופיע אזהרה כמו MovementCheck: YourName moved 60 studs/s. החזירו ל-16, ואז רוצו ועשו דאשים כרגיל במשך דקה, ובדקו שה-Output שותק.
  10. אם בפלייס שלכם Workspace.PlayerScriptsUseInputActionSystem קבוע ל-Enabled, בדקו שוב את הקפיצה הכפולה: התיעוד של Roblox לא אומר אם JumpRequest מתנהג איתו אותו דבר.

אם בכלל שום דבר לא קורה, פתחו את חלון ה-Output דרך תפריט Window ב-Studio וחפשו שגיאה אדומה מ-MovementClient, או הציצו בשגיאות נפוצות.

כמה מהר וכמה זמן: הגדרות מוכנות לפי סוג משחק

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

מהירות הליכה, ריצה וסיבולת לפי סוג משחק. זמן הריצה הוא MAX_STAMINA / DRAIN_PER_SECOND; ההתחדשות היא MAX_STAMINA / REGEN_PER_SECOND ועוד שנייה אחת של REGEN_DELAY
סוג משחקCharacterWalkSpeedSPRINT_BONUS (מהירות ריצה)DRAIN_PER_SECONDREGEN_PER_SECONDריצה מלאהמריק למלאמרחק בפס אחד
המדריך הזה1610 (26)20155 שנ׳7.7 שנ׳130 studs
מרדף באימה128 (20)25104 שנ׳11 שנ׳80 studs
Battlegrounds וקרב1612 (28)15206.7 שנ׳6 שנ׳בערך 187 studs
עולם פתוח או סימולטור1616 (32)102510 שנ׳5 שנ׳320 studs
אובי או פארקור168 (24)בלי סיבולת: השתמשו ב-ShiftToSprint
  • את מהירות ההליכה קובעים ב-StarterPlayer. סמנו את StarterPlayer וקבעו את CharacterWalkSpeed (ברירת מחדל 16). כל דמות חדשה מתחילה במהירות הזו, הריצה מוסיפה לה SPRINT_BONUS, וגם MovementCheck קורא אותה, כך שהבדיקה בשרת הולכת לפי הבחירה שלכם.
  • MovementCheck מתאים את עצמו. הוא מתיר את מהירות ההליכה ועוד בונוס הריצה ועוד רבע ל-lag: 25 studs בשנייה להגדרת האימה, 40 לעולם הפתוח. לא צריך לשנות שום דבר נוסף.
  • באובי הריצה משנה את המסלול. עם ריצה מהירה יותר אפשר לקפוץ מעל תהומות ארוכות יותר. בנו את הקפיצות, ואז בדקו כל אחת במהירות הריצה, אחרת הריצה תהפוך את השלבים לקלים מדי. המדריך לצ׳קפוינטים באובי משתלב טוב עם ShiftToSprint.
  • באימה נקודת הייחוס היא הרוצח. עשו את הרודף קצת מהיר יותר ממהירות ההליכה וקצת איטי יותר מהריצה, כדי שהבריחה תהיה תלויה במתי הפס נגמר. המדריך למשחק אימה מפרט את שאר הלולאה.

מה לא בסדר בסקריפטי ריצה ישנים

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

טריקים ממדריכים ישנים ומה המדריך הזה עושה במקומם
טריקמה הבעיההמדריך הזה
BodyVelocity לדאשמיושן: Roblox אומרת להשתמש במקומו ב-LinearVelocityLinearVelocity במצב Plane
לולאה על RunService.RenderSteppedלעבודה חדשה PreRender החליף אותו. ללוגיקת משחק כמו סיבולת המקום הוא Heartbeat, ש-Roblox מתארת למשימות מחזוריות כמו התחדשות חייםHeartbeat עם deltaTime
לולאת סיבולת על wait()wait() מיושן לטובת task.wait() ומואט, ולכן יכול לחכות יותר ממה שביקשו, והוצאה קבועה על כל wait מוציאה סיבולת בצורה לא אחידההוצאה והתחדשות בכל פריים לפי deltaTime
UserInputService.InputBegan בלי בדיקת צ׳אטלחיצה על Shift בזמן הקלדת הודעה בצ׳אט מפעילה ריצהContextActionService, שגם מוסיף כפתור בטלפון
WalkSpeed = 16 בשחרור או בכל פרייםדורס כל מהירות אחרת, למשל הטבה של Game Passמשנה את WalkSpeed רק בתחילת הריצה ובסופה, ומוסיף לערך הנוכחי
ריצה דרך RemoteEvent, כדי שהשרת יקבע את WalkSpeedאקספלויטרים בכל זאת קובעים לעצמם WalkSpeed, והריצה מתחילה באיחור של הלוך ושובריצה בלקוח ועוד בדיקת מרחק בשרת
קפיצה כפולה על כל JumpRequestJumpRequest נורה כמה פעמים לבקשת קפיצה אחת, וכפתור לחוץ יכול להמשיך לבקש קפיצותהפסקה של 0.25 שנייה ובדיקה של לחיצה חדשה
UserInputService.TouchEnabled כבדיקת "זה טלפון"הוא שווה true במחשבים ניידים עם מסך מגעContextActionService מוסיף כפתורים למסך במכשירי מגע בלי בדיקת מכשיר משלכם
Humanoid:LoadAnimation לאנימציית ריצהמיושן לטובת Animator:LoadAnimationאנימציית ריצה שלמטה משתמשת ב-Animator

הדרך החדשה של Roblox: Input Action System

העמוד של Roblox על Input Action System לוקח ריצה של דמות כדוגמה הראשונה. במקום קריאות BindAction, השליטה מוגדרת ב-Studio: InputAction בשם CharacterSprint בתוך input context ב-ReplicatedStorage, עם InputBinding אחד ל-Left Shift, אחד לכפתור Y בג׳ויפד ואחד שמקושר לכפתור במסך שאתם מציירים ב-StarterGui. אז סקריפט לקוח מאזין לאירועי הפעולה Pressed ו-Released, מכפיל את WalkSpeed בלחיצה ומחזיר אותו בשחרור.

כדאי לעבור אליו אם אתם רוצים לפרוס את השליטה ב-Studio ולא בקוד, כפתור מגע משלכם במקום הכפתור של ContextActionService, או הקשרים שמחליפים סטים שלמים של שליטה, למשל לתפריטים או לכלי רכב. העמוד גם ממליץ לקבוע את Workspace.PlayerScriptsUseInputActionSystem ל-Enabled, ו-server authority דורש את זה.

לולאת הסיבולת והדאש מהמדריך הזה עובדים אותו דבר עם Input Action System לבד (בלי server authority). השאירו את MovementConfig, את לולאת ה-Heartbeat ואת dash(), מחקו את שתי קריאות ה-BindAction ואת ה-handlers שלהן, וחברו במקומן את הפעולות: Pressed של פעולת הריצה קובע את sprintHeld ל-true, ה-Released שלה ל-false, ו-Pressed של פעולת הדאש קורא ל-dash(). המשיכו לחפש את ה-Humanoid בכל פריים, כמו ש-MovementClient עושה, כי הדוגמה מהתיעוד שומרת את ה-Humanoid של הדמות הראשונה, ואחרי לידה מחדש הוא כבר לא קיים.

Roblox גם בודקת את Character Controller Library, בטא שמפעילים ב-Beta Features וב-Avatar Settings ב-Studio. העמוד שלה על יכולות משלכם בונה כדוגמה דאש עם חלון פעיל של 0.2 שנייה וזמן המתנה של שנייה אחת, כלומר עם אותו תזמון כמו הדאש מהמדריך הזה.

איך להרחיב: אנימציה, מצלמה ו-pass לריצה

אנימציית ריצה

צרו אנימציית ריצה ב-Animation Editor, תנו לה את העדיפות Movement (Roblox ממליצה עליה לאנימציות הליכה וריצה), פרסמו אותה והעתיקו את ה-Asset ID. ב-MovementClient צרו Animation עם ה-AnimationId הזה, טענו אותה דרך Animator:LoadAnimation, תוך שימוש ב-Animator שבתוך ה-Humanoid של הדמות, הפעילו את הטראק במקום שבו הריצה מתחילה, ועצרו במקום שבו היא נגמרת. טענו אותה מחדש לכל דמות חדשה.

אנימציות שהמכשיר שלכם מפעיל על הדמות שלכם, כולם רואים, אם אתם משתמשים ב-Animator ש-Roblox שמה שם: טראקים שנטענו על Animator ש-LocalScript יצר לא משוכפלים. Humanoid:LoadAnimation, שהרבה מדריכים ישנים משתמשים בו, מיושן.

מצלמה רחבה יותר בזמן ריצה

זווית ראייה קצת רחבה יותר גורמת לריצה להרגיש מהירה יותר. באותם שני מקומות עשו טווין ל-workspace.CurrentCamera.FieldOfView מערך ברירת המחדל 70 לבערך 80 כשהריצה מתחילה, ובחזרה כשהיא נגמרת, למשל דרך TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox מגבילה את הערך בין 1 ל-120 ומזהירה שערכים נמוכים או גבוהים מאוד עלולים לבלבל שחקנים. אם עוד סקריפט במשחק משנה את זווית הראייה, עשו טווין חזרה לערך שמצאתם, ולא ל-70.

ריצה מהירה כ-Game Pass

המדריך ל-Game Passes כבר עובד עם הסקריפט הזה: הטבת ה-Speed שלו קובעת בשרת WalkSpeed 24 לכל דמות חדשה, MovementClient מוסיף מעל את בונוס הריצה, ו-34 studs בשנייה נשארים בגבולות של מה ש-MovementCheck מתיר.

ל-pass שמאיץ את הריצה עצמה, הוסיפו pass בשם FastSprint ל-PassConfig.ids מאותו מדריך. סקריפט השרת שלו אז קובע לשחקן את ה-Attribute בשם OwnsPass_FastSprint ברגע שהקנייה אושרה. ב-MovementClient השתמשו בבונוס גדול יותר מ-Config.SPRINT_BONUS כש-player:GetAttribute("OwnsPass_FastSprint") == true. ב-MovementCheck תנו לשחקנים כאלה סובלנות גדולה יותר, על ידי קריאה של אותו Attribute בשרת, שבו השחקן לא יכול לשנות אותו, ובדקו שהמהירות המקסימלית החדשה נשארת מתחת למה שהבדיקה מסמנת.

מגבלה אחת שכדאי לדעת עליה: אם סקריפט אחר משנה את WalkSpeed באמצע ריצה, סוף הריצה הזו יחזיר את המהירות שהייתה לפניה. הלידה מחדש הבאה תקבע שוב את המהירות של ה-pass, כי סקריפט ה-Game Pass מחיל אותה על כל דמות חדשה.

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

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

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

MovementClient או MovementCheck מחכים למודול שלא קיים בשם המדויק הזה. זה צריך להיות ModuleScript בשם MovementConfig ישירות בתוך ReplicatedStorage. המדריך לשגיאות בסקריפטים מפרט את האזהרה הזו.

Shift לא עושה כלום

בדקו ש-ShiftToSprint או MovementClient הם LocalScript, לא Script, ושהם נמצאים ב-StarterPlayerScripts. עם MovementClient, כדי להתחיל לרוץ הדמות צריכה גם ללכת ושתהיה לה לפחות 20 סיבולת, אז החזיקו Shift בזמן תנועה. אם במקום ריצה מתחלף Shift Lock, ראו את השאלה על Shift Lock למטה.

הריצה נעצרת אחרי כמה שניות

זו הסיבולת שנגמרת: 100 סיבולת ב-20 בשנייה מספיקה ל-5 שניות. הגדילו את MAX_STAMINA או הקטינו את DRAIN_PER_SECOND ב-MovementConfig.

הדאש לא עושה כלום

הדאש צריך 25 סיבולת, מחכה שנייה אחרי הקודם ולא עושה כלום בזמן שאתם יושבים. אם זה לא העניין, ייתכן שב-Part הראשי של הדמות שלכם אין Attachment בשם RootAttachment, וזה קורה בחלק מהדמויות המותאמות: הוסיפו אותו ל-HumanoidRootPart של ה-StarterCharacter שלכם.

הקפיצה הכפולה לא עובדת

DoubleJump חייב להיות LocalScript ב-StarterCharacterScripts, לא ב-StarterPlayerScripts, כי הוא קורא את script.Parent כדמות. לחצו על קפיצה פעם שנייה אחרי שהתנתקתם מהקרקע: כפתור לחוץ לא נחשב ללחיצה חדשה, וירידה ממדף לא נותנת קפיצה באוויר.

בטלפון אין כפתור Sprint או Dash

ContextActionService מוסיף את הכפתורים שלו רק במכשירי מגע, ולכן במחשב בלי מסך מגע הם אף פעם לא נראים. בדקו עם טלפון ב-Device Simulator ב-Studio (זו בטא: הפעילו את New Device Simulator ב-File, Beta Features והפעילו מחדש את Studio). BindAction יכול ליצור לא יותר מ-7 כפתורי מגע, אז ספרו כמה מהם סקריפטים אחרים במשחק יוצרים.

MovementCheck מתלונן על שחקנים הגונים

הסיבות הרגילות: טלפורט מסקריפט שרת אחר, מסוע או כלי רכב, או lag. קבעו את ה-Attribute בשם MovementCheckSkip אחרי הטלפורטים שלכם (ראו לידות מחדש וטלפורטים), והגדילו את SPEED_ALLOWANCE אם הבדיקה עדיין נורית במשחק רגיל.

ההאצה נעלמת אחרי ריצה

סקריפט אחר שינה את WalkSpeed בזמן ריצה, והריצה, כשנגמרה, החזירה את המהירות שראתה בהתחלה. תנו האצות בלידה של הדמות, כמו שהמדריך ל-Game Passes עושה, כדי שלידה מחדש תקבע שוב את המהירות הנכונה.

לעשות עם RoCode

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

אתם כותבים

תוסיף ריצה על Shift עם פס סיבולת: מהירות הליכה ועוד 10 כל עוד Shift לחוץ, 100 סיבולת, הוצאה של 20 בשנייה, התחדשות של 15 בשנייה אחרי שנייה מנוחה, כפתור Sprint בטלפונים, דאש על Q וקפיצה כפולה.

RoCode עושה
  • יכול קודם לסרוק את הפלייס שלכם עם Search Scripts ו-Read Script, כדי למצוא סקריפטים אחרים שמשנים את WalkSpeed (למשל הטבה של Game Pass), כך שהריצה תתווסף אליהם
  • כותב ModuleScript, LocalScripts ובדיקה בשרת עם Create Script
  • הוא מונחה לבדוק את הקומפילציה של כל סקריפט שכתב עם Check Script, שמקמפל אותו ב-Studio בלי להריץ
  • מציב נקודת ביטול לפני ואחרי כל קבוצת שינויים, ולכן Ctrl+Z מחזיר קבוצה אחת בכל פעם

RoCode לא יודע ליצור אנימציית ריצה: צרו אותה ב-Animation Editor והדביקו את ה-ID שלה. עם פלאגין 3.9.11 ומעלה RoCode יכול להריץ בדיקת משחק של המשחק שלכם ב-Studio ולשלוט בדמות בדיקה כדי לבדוק שהכול עובד, ועם פלאגין 3.9.15 ומעלה דמות הבדיקה יכולה ללחוץ על מקשים, למשל להחזיק Shift ולבדוק ש-WalkSpeed עלה. הוא מחליט בעצמו מתי להריץ בדיקת משחק, עד 2 לבנייה ועוד 1 כדי לבדוק את התיקון שלו, ובודק רק את מה שהוא עצמו החליט לבדוק, אז נסו בעצמכם את הריצה, הדאש והקפיצה הכפולה, ואת הכפתורים בטלפון בדקו ב-Device Simulator ב-Studio. תנועה היא מערכת אחת מתוך הרבה במשחק; יצירת משחק שלם עם RoCode הולכת מערכת אחת לכל פרומפט, כמו כאן. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

למה סקריפט הריצה לא עובד בטלפון?

לטלפון אין מקש Shift. קשרו את הריצה דרך ContextActionService:BindAction והעבירו true כארגומנט שלישי: זה מוסיף כפתור למסך במכשירי מגע, כמו שגם ShiftToSprint וגם MovementClient עושים.

צריך לעשות את הריצה בשרת?

לא. כל מכשיר מזיז את הדמות שלו, ולכן WalkSpeed שהשרת קבע לא יעצור רמאי שיכול לקבוע משלו, והמהירות החדשה מגיעה רק אחרי הלוך ושוב, כך שהריצה מתחילה באיחור. עשו את הריצה בלקוח, ובשרת בדקו כמה רחוק דמויות באמת זזות, כמו בשלב 5. הבטא של server authority של Roblox בנויה אחרת, ואת קוד התנועה תצטרכו לשכתב בשבילה.

למה הדמות ממשיכה לרוץ אחרי ששחררתי את Shift?

הסקריפט פספס את השחרור, בדרך כלל כי הוא מאזין רק ללחיצה. ContextActionService שולח End כשמשחררים את המקש, ו-Cancel כשקישור אחר לוקח אותו; MovementClient עוצר בשניהם, וגם כשהסיבולת נגמרת או שהדמות מפסיקה לזוז.

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

טענו אנימציית ריצה דרך ה-Animator ב-Humanoid של הדמות באותו LocalScript, הפעילו אותה כשהריצה מתחילה, ועצרו כשהיא נגמרת. תנו לה את העדיפות Movement. אנימציות שמופעלות על הדמות שלכם עצמה, כולם רואים.

למה הקפיצה הכפולה בטלפון נורית לבד?

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

מה מהירות ההליכה ב-Roblox כברירת מחדל?

16 studs בשנייה. היא באה מ-StarterPlayer.CharacterWalkSpeed, שקובע את Humanoid.WalkSpeed של כל דמות חדשה. הריצה מהמדריך הזה מוסיפה 10, כך שהריצה היא ב-26.

באיזו מהירות צריכה להיות ריצה ב-Roblox?

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

איך יוצרים ריצה עם סיבולת?

שמרו מספר סיבולת במכשיר של השחקן, הוציאו אותו בכל פריים בזמן ריצה וחדשו אותו אחרי מנוחה קצרה, בשני המקרים לפי זמן הפריים, ועצרו את הריצה כשהוא מגיע ל-0. MovementClient משלב 3 עושה את זה עם פס במסך; המספרים נמצאים ב-MovementConfig.

איך רצים עם בקר ב-Roblox?

קשרו את ButtonL3 של הג׳ויפד (לחיצה על הסטיק השמאלי) דרך ContextActionService יחד עם Left Shift, כמו ששני הסקריפטים כאן עושים. ShiftToSprint הופך את L3 למתג, כי להחזיק את הסטיק לחוץ ובו-זמנית לנווט איתו מעייף.

ריצה על Shift מתנגשת עם Shift Lock?

יכולה. שחקנים שהפעילו Shift Lock בהגדרות של Roblox מחליפים אותו במקש Shift, כך שמקש אחד עושה שני דברים. בתיעוד של Roblox כתוב שה-API של Shift Lock יוצאים משימוש. אם ההתנגשות מפריעה לשחקנים שלכם, כבו את StarterPlayer.EnableMouseLockOption, או קשרו את הריצה ב-MovementClient למקש אחר, למשל Left Ctrl.

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

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

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

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