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

Roblox Studio में PC, फ़ोन और कंसोल के लिए Shift से स्प्रिंट कैसे बनाएं

Roblox में Shift से स्प्रिंट एक नंबर पर टिका है: Humanoid का WalkSpeed, जो Shift दबाए रखने पर बढ़ता है। स्टेप 1 एक छोटी LocalScript में ठीक यही करता है, जो फ़ोन के Sprint बटन और गेमपैड के साथ भी काम करती है। गाइड का बाकी हिस्सा वह जोड़ता है जो बड़े गेम को चाहिए: स्टैमिना बार, आधुनिक फ़िज़िक्स पर डैश, ऐसा डबल जंप जो दबाए रखे बटन से न चले, और यह समझ कि सर्वर क्या जाँच सकता है और क्या नहीं।

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

संक्षेप में

StarterPlayerScripts में एक LocalScript रखें, जो ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3) से Sprint ऐक्शन बाँधे। जब तक Shift दबा है, Humanoid.WalkSpeed में 10 जोड़ें (16 से 26 बनता है), और छोड़ने पर पुराना मान वापस करें। true आर्ग्युमेंट टच स्क्रीन पर Sprint बटन जोड़ता है, और इस गाइड की स्क्रिप्ट में यह बटन और गेमपैड का L3 स्प्रिंट को चालू और बंद करते हैं, दबाए रखने पर काम नहीं करते।

  • मौजूदा WalkSpeed में जोड़ें, सीधे 26 सेट न करें, ताकि गेमपास वाली स्पीड बनी रहे।
  • स्प्रिंट प्लेयर के डिवाइस पर चलता है। सर्वर 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 MovementClientStarterPlayerScriptsSprint और 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: एक LocalScript में Shift से स्प्रिंट

अगर आपको सिर्फ़ Shift दबाए रखने पर तेज़ दौड़ना चाहिए, तो यह एक स्क्रिप्ट काफ़ी है। यह फ़ोन को स्क्रीन पर Sprint बटन भी देती है, और गेमपैड पर बाएँ स्टिक से दौड़ने देती है।

  1. Explorer में StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ, + बटन दबाएँ और ShiftToSprint नाम की एक LocalScript डालें।
  2. उसकी सामग्री नीचे के कोड से बदलें और Play दबाएँ।
LocalScript स्थान: StarterPlayerScripts नाम: ShiftToSprint
-- StarterPlayer > StarterPlayerScripts में ShiftToSprint नाम की LocalScript।
-- दौड़ने के लिए 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" लिखता है। हैंडलर इनपुट भी पाता है, इसलिए कीबोर्ड दबाने को गेमपैड या टच बटन से अलग पहचानता है। स्प्रिंट शुरू होने पर स्क्रिप्ट मौजूदा WalkSpeed याद रखती है और SPRINT_BONUS जोड़ती है; ख़त्म होने पर याद रखा मान वापस करती है। किसी दूसरी स्क्रिप्ट की सेट की हुई स्पीड, जैसे गेमपास गाइड का Speed perk, बनी रहती है। नया कैरेक्टर सामान्य WalkSpeed से शुरू होता है, इसलिए CharacterAdded हैंडलर सिर्फ़ फ़्लैग रीसेट करता है।

होल्ड या टॉगल?

जब TOGGLE_ON_TOUCH_AND_GAMEPAD true है, तो ShiftToSprint हर डिवाइस पर कैसे काम करती है
डिवाइस और इनपुटकैसे काम करता हैक्यों
कीबोर्ड: Left Shiftहोल्डचलते समय कुंजी दबाए रखना आसान है, और छोड़ते ही स्प्रिंट रुक जाता है।
गेमपैड: बाएँ स्टिक को दबाना (L3)टॉगलस्टिक को दबाए रखते हुए उसी से दिशा देना थकाऊ है।
फ़ोन या टैबलेट: स्क्रीन पर Sprint बटनटॉगलजो अँगूठा बटन दबाए है, वह उसी समय Jump नहीं दबा सकता।

जाँचने के लिए Play दबाएँ और चलते समय Shift दबाए रखें: स्पीड 16 से 26 स्टड प्रति सेकंड हो जाती है, और छोड़ने पर आप धीमे हो जाते हैं। फ़ोन के लिए Studio के Device Simulator में एक फ़ोन चुनें, Play दबाएँ और शुरू करने के लिए Sprint एक बार दबाएँ, रोकने के लिए फिर एक बार। गेमपैड के लिए playtest के दौरान 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, -- डैश के दौरान स्टड प्रति सेकंड
	DASH_SECONDS = 0.2, -- इससे डैश लगभग 12 स्टड जाता है
	DASH_COST = 25, -- स्टैमिना
	DASH_COOLDOWN = 1,
}

return MovementConfig
हर सेटिंग क्या करती है
सेटिंगमानअसर
SPRINT_BONUS10स्प्रिंट के दौरान WalkSpeed में जुड़ता है। Roblox में डिफ़ॉल्ट WalkSpeed 16 है, इसलिए स्प्रिंट 26 स्टड प्रति सेकंड पर होता है।
MAX_STAMINA100पूरा बार।
DRAIN_PER_SECOND20पूरा बार 5 सेकंड के स्प्रिंट के लिए काफ़ी है।
REGEN_PER_SECOND15ख़ाली बार लगभग 6.7 सेकंड में भरता है।
REGEN_DELAY1भरना शुरू होने से पहले आराम के सेकंड।
MIN_TO_START20स्प्रिंट शुरू करने के लिए ज़रूरी स्टैमिना।
DASH_SPEED60डैश के दौरान स्टड प्रति सेकंड।
DASH_SECONDS0.2डैश कितनी देर चलता है: 60 स्टड प्रति सेकंड पर लगभग 12 स्टड।
DASH_COST25हर डैश की स्टैमिना।
DASH_COOLDOWN1दो डैश के बीच सेकंड।

हर तरफ़ मॉड्यूल की अपनी कॉपी चलाती है (मॉड्यूल हर तरफ़ एक बार चलता है), इसलिए जो प्लेयर अपने डिवाइस पर ये नंबर बदलता है, वह सिर्फ़ अपनी कॉपी बदलता है। लेकिन यहाँ इससे कुछ सुरक्षित नहीं होता: उसका डिवाइस वैसे भी उसके कैरेक्टर को चलाता है, इसलिए मॉड्यूल में कुछ भी हो, वह ख़ुद को अनंत स्टैमिना दे सकता है। स्टेप 5 की सर्वर जाँच इसी को ध्यान में रखकर बनी है।

स्टेप 3: स्टैमिना वाला स्प्रिंट और डैश

यह LocalScript वह करती है जो प्लेयर महसूस करते हैं। यह Sprint और Dash बाँधती है, स्टैमिना बार बनाती है, हर फ़्रेम स्टैमिना लूप चलाती है और डैश करती है।

  1. Explorer में StarterPlayer खोलें, StarterPlayerScripts पर कर्सर ले जाएँ और MovementClient नाम की एक LocalScript डालें।
  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

	-- Plane मोड में LinearVelocity क्षैतिज स्पीड रखता है और गुरुत्वाकर्षण में दख़ल नहीं देता
	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 सिर्फ़ स्प्रिंट की शुरुआत और अंत में बदलते हैं, ताकि किसी
	-- दूसरी स्क्रिप्ट की सेट की हुई स्पीड (जैसे स्पीड पास) बनी रहे, और स्प्रिंट उसमें जुड़े
	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 के साथ बनता है, इसलिए respawn के बाद स्क्रीन पर रहता है, और नीचे का CharacterAdded हैंडलर हर नए कैरेक्टर के लिए उसे फिर से भरता है। type Config वाली लाइनें बताती हैं कि मॉड्यूल क्या लौटाता है, ताकि strict type checking सेटिंग के नाम में टाइपो पकड़ ले; गेम के दौरान वे कुछ नहीं बदलतीं।

एक ही कॉल में कीबोर्ड, गेमपैड और फ़ोन का बटन

ContextActionService:BindAction ऐक्शन का नाम, हैंडलर फ़ंक्शन, टच बटन बनाना है या नहीं, और फिर इनपुट लेता है। तीसरे आर्ग्युमेंट के रूप में true देने पर ContextActionService टच डिवाइस पर स्क्रीन पर एक बटन जोड़ता है, प्लेयर के PlayerGui में ContextActionGui नाम के ScreenGui के अंदर। SetTitle इन बटनों पर "Sprint" और "Dash" लिखता है। BindAction 7 से ज़्यादा टच बटन नहीं बना सकता, इसलिए अगर गेम की दूसरी स्क्रिप्ट भी इन्हें इस्तेमाल करती हैं, तो गिनती पर नज़र रखें।

हैंडलर इनपुट की स्थिति पाता है: दबाने पर Begin और छोड़ने पर End। onSprint सिर्फ़ याद रखता है कि Sprint दबा है या नहीं। वह Cancel को भी छोड़ना मानता है, जिसे ContextActionService तब भेजता है जब कोई दूसरी binding इनपुट ले लेती है, और Change को नज़रअंदाज़ करता है, जो टच बटन पर खिसकती उँगली भेज सकती है। दोनों हैंडलर Pass लौटाते हैं, इसलिए उसी कुंजी की अगली binding को भी इनपुट मिलता है।

Roblox का ContextActionService रेफ़रेंस ज़्यादातर मामलों में UserInputService.InputBegan की जगह इसे सुझाता है। उसका उदाहरण: H पर कार का हॉर्न, जो प्लेयर के चैट में लिखते समय नहीं बजना चाहिए। Binding तभी चलती है जब वह उस इनपुट की आख़िरी binding हो, इसलिए जब चैट कीबोर्ड ले लेता है, तो आपको कुछ जाँचना नहीं पड़ता। गेमपैड इनपुट: ButtonL3 (बाएँ स्टिक को दबाना, जिसे चलते समय दबाए रखा जाता है) और ButtonB। Roblox के अपने स्प्रिंट उदाहरण में ButtonY है, इसलिए अगर आपके गेम में वह बेहतर लगे, तो BindAction में KeyCode बदल दें।

स्टैमिना लूप

RunService.Heartbeat हर फ़्रेम फ़िज़िक्स स्टेप के बाद चलता है और deltaTime देता है, यानी पिछले फ़्रेम से बीते सेकंड। अगर ख़र्च और भरने की रफ़्तार इससे गुणा की जाए, तो पूरा बार 5 सेकंड चलेगा, चाहे गेम 30 पर चले या 240 फ़्रेम प्रति सेकंड पर।

हर फ़्रेम लूप तय करता है कि कैरेक्टर को स्प्रिंट करना चाहिए या नहीं: Sprint दबा है, कैरेक्टर चल रहा है (खड़े होने पर Humanoid.MoveDirection शून्य वेक्टर होता है) और स्टैमिना बची है। स्प्रिंट शुरू करने के लिए कम से कम MIN_TO_START (20) चाहिए; जारी रखने के लिए 0 से ज़्यादा कुछ भी काफ़ी है। इस अंतर के बिना ख़ाली बार, जो हर फ़्रेम थोड़ा भरता है, हर फ़्रेम स्प्रिंट चालू-बंद करता। भरना आख़िरी स्प्रिंट या डैश के REGEN_DELAY (1 सेकंड) बाद शुरू होता है, इसलिए बार ख़ाली करने के बाद प्लेयर फिर स्प्रिंट करने से पहले लगभग 2.3 सेकंड इंतज़ार करता है।

WalkSpeed सिर्फ़ उसी फ़्रेम में बदलता है जब स्प्रिंट शुरू या ख़त्म होता है। शुरुआत में स्क्रिप्ट मौजूदा WalkSpeed याद रखती है और SPRINT_BONUS जोड़ती है; अंत में याद रखा मान वापस करती है। इसलिए दूसरी स्क्रिप्ट की सेट की हुई स्पीड बनी रहती है: गेमपास गाइड का Speed perk WalkSpeed 24 सेट करता है, और इस स्क्रिप्ट के साथ उसके मालिक 34 पर दौड़ते हैं। जो स्क्रिप्ट हर फ़्रेम या हर बार छोड़ने पर WalkSpeed = 16 लिखती है, वह चुपचाप इस perk को रद्द कर देती।

डैश

डैश कैरेक्टर को उस दिशा में धकेलता है जहाँ वह जा रहा है, या खड़े होने पर जहाँ वह देख रहा है, और दिशा समतल की जाती है ताकि कभी ऊपर या नीचे न हो। इसकी कीमत 25 स्टैमिना है, यह स्प्रिंट की तरह भरना रोकता है, और इसका cooldown 1 सेकंड है। इसमें ज़मीन की जाँच नहीं है, इसलिए यह हवा में भी काम करता है, जो डबल जंप के साथ अच्छा जमता है। कैरेक्टर बैठा हो तो डैश कुछ नहीं करता: बैठा कैरेक्टर सीट से जुड़ा होता है, और गाड़ी में धक्का पूरी गाड़ी को खिसका सकता है।

धक्का root पार्ट के RootAttachment पर एक LinearVelocity constraint है। X और Z अक्षों के साथ Plane मोड में यह 60 स्टड प्रति सेकंड की क्षैतिज स्पीड रखता है और ऊर्ध्वाधर को नहीं छूता, इसलिए गुरुत्वाकर्षण काम करता है, और किनारे से डैश सामान्य रूप से गिरता है। MaxForce, math.huge है, इसलिए धक्का किसी चीज़ से सीमित नहीं। Debris:AddItem स्क्रिप्ट को इंतज़ार कराए बिना DASH_SECONDS बाद constraint हटा देता है, इसलिए डैश 0.2 सेकंड चलता है, इस स्पीड पर लगभग 12 स्टड।

पुराने ट्यूटोरियल BodyVelocity इस्तेमाल करते हैं, जिसे Roblox ने deprecated बताया है और उसकी जगह LinearVelocity इस्तेमाल करने को कहा है। एक अक्ष पर शून्य MaxForce वाली उसकी तरकीब की जगह LinearVelocity के Line, Plane और Vector मोड लेते हैं। क्योंकि प्लेयर का डिवाइस ख़ुद अपने कैरेक्टर को simulate करता है, LocalScript का बनाया constraint उसे हिलाता है, और दूसरे प्लेयर डैश को किसी भी दूसरी हलचल की तरह देखते हैं।

Roblox का अपना UI ट्यूटोरियल भी constraint को ठीक इसी तरह humanoid.RootPart.RootAttachment से जोड़ता है। अगर आपके गेम में अपना कैरेक्टर है जिसके root पार्ट में RootAttachment नाम का Attachment नहीं है, तो डैश कुछ नहीं करता: उसे अपने StarterCharacter के HumanoidRootPart में जोड़ें।

स्टेप 4: डबल जंप

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

  1. Explorer में StarterPlayer खोलें, StarterCharacterScripts पर कर्सर ले जाएँ और DoubleJump नाम की एक LocalScript डालें।
  2. उसकी सामग्री नीचे के कोड से बदलें।
LocalScript स्थान: StarterCharacterScripts नाम: DoubleJump
-- हवा में एक अतिरिक्त जंप देती है। हर नए कैरेक्टर के लिए फिर से चलती है,
-- इसलिए respawn के बाद कुछ आगे नहीं जाता।

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 में जाता है, इसलिए हवा का जंप नहीं मिलता। अगर वहाँ भी चाहिए, तो Jumping के सिवा किसी भी स्थिति से Freefall में जाने पर भी jumpsLeft सेट करें।

UserInputService.JumpRequest तब चलता है जब प्लेयर जंप माँगता है, जैसे Space या फ़ोन के जंप बटन से। Roblox का रेफ़रेंस चेतावनी देता है कि यह एक जंप अनुरोध पर कई बार चलता है और debounce सुझाता है, इसलिए स्क्रिप्ट आख़िरी जंप के 0.25 सेकंड तक अनुरोध नज़रअंदाज़ करती है। दबाए रखा जंप बटन भी जंप माँगता रह सकता है और कैरेक्टर के ज़मीन छोड़ते ही हवा का जंप ख़र्च कर देता, इसलिए अनुरोध को नया दबाना तभी माना जाता है जब 0.1 सेकंड तक कोई अनुरोध न आया हो।

हवा का जंप ख़ुद Humanoid:ChangeState(Enum.HumanoidStateType.Jumping) है। Roblox का रेफ़रेंस कहता है कि इसे उस डिवाइस की LocalScript से कॉल करना चाहिए जिसके पास कैरेक्टर का network ownership है, और डिफ़ॉल्ट रूप से यह प्लेयर का अपना डिवाइस है, सर्वर नहीं। रेफ़रेंस में ChangeState का कोड उदाहरण ठीक डबल जंप ही है।

स्टेप 5: सर्वर पर स्पीड हैक पकड़ना

स्प्रिंट ट्यूटोरियल अक्सर क्लाइंट पर रुक जाते हैं। सर्वर Script प्लेयर के WalkSpeed पर भरोसा नहीं कर सकती, क्योंकि exploiter उसे अपने डिवाइस पर बदलते हैं, लेकिन वह देखती है कि उनका कैरेक्टर कहाँ पहुँचता है। MovementCheck इसे सेकंड में दो बार मापती है और Output में चेतावनी लिखती है जब कोई लंबे समय तक स्प्रिंट और डैश की इजाज़त से तेज़ चलता है। स्प्रिंट और डैश के नंबर वह MovementConfig से पढ़ती है, इसलिए स्टेप 2 का यह मॉड्यूल जोड़ें, भले ही आपने ShiftToSprint रखी हो।

  1. ServerScriptService पर कर्सर ले जाएँ और MovementCheck नाम की एक Script डालें।
  2. उसकी सामग्री नीचे के कोड से बदलें।
Script स्थान: ServerScriptService नाम: MovementCheck
-- प्लेयर के डिवाइस अपने कैरेक्टर चलाते हैं, इसलिए exploiter कोई भी WalkSpeed सेट कर सकता है।
-- यह जाँच मापती है कि हर कैरेक्टर असल में कितनी दूर जाता है, और Output में लिखती है
-- जब कोई लंबे समय तक स्प्रिंट और डैश की इजाज़त से तेज़ चलता है। यह सिर्फ़ चेतावनी देती है:
-- लैग, टेलीपोर्ट और कन्वेयर स्पीड से ज़्यादा जैसे दिख सकते हैं, इसलिए किसी को सज़ा देने से पहले इसे सेट करें।

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 -- सेकंड
-- स्प्रिंट की स्पीड और लैग की गुंजाइश। अगर आप स्पीड बूस्ट बेचते हैं, तो बढ़ाएँ।
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 } = {} -- root पार्ट जिस पर lastPosition मापी गई
local excess: { [Player]: number } = {} -- छूट से ऊपर के स्टड, धीरे-धीरे माफ़ होते हैं

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
			-- Respawn नया root पार्ट है, और सर्वर टेलीपोर्ट (राउंड की शुरुआत, चेकपॉइंट)
			-- नीचे का 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

चेतावनी Studio में Output में दिखती है। लाइव गेम में यह Developer Console के सर्वर लॉग में जाती है, जिसे आप गेम के मालिक के रूप में पढ़ सकते हैं: देखें लाइव गेम में आउटपुट।

यह क्या मापती है

हर आधे सेकंड में स्क्रिप्ट हर कैरेक्टर के root पार्ट की पोज़िशन पढ़ती है और मापती है कि पिछली जाँच से वह क्षैतिज रूप से कितना खिसका। ऊँचाई नज़रअंदाज़ होती है, इसलिए गिरना और कूदना कभी नहीं गिना जाता; मूवमेंट जाँच पर Roblox की सलाह ज़मीन पर चलने वाले गेम के लिए XZ समतल पर यही projection सुझाती है। छूट डिफ़ॉल्ट चलने की स्पीड, स्प्रिंट बोनस और लैग के लिए एक चौथाई और है: 32.5 स्टड प्रति सेकंड। इससे ज़्यादा दूरी एक «leaky bucket» में जाती है, ऐसा संचय जिसके बारे में Roblox डॉक्यूमेंटेशन कहती है कि कई डेवलपर के लिए यह छोटे झटकों पर अच्छा काम करता है। बाल्टी हर जाँच पर 3 स्टड खोती है, और स्क्रिप्ट चेतावनी देती है जब उसमें 24 स्टड से ज़्यादा हो, यानी लगभग दो डैश की गुंजाइश।

इसके नंबरों से गिनें तो जाँच क्या पकड़ती है
चीटरMovementCheck क्या करती है
WalkSpeed 100 सेट करता हैलगभग एक सेकंड दौड़ने के बाद चेतावनी देती है
WalkSpeed 50 सेट करता हैलगभग 2.5 सेकंड दौड़ने के बाद चेतावनी देती है
बिना cooldown के लगातार डैश करता है (60 स्टड प्रति सेकंड)लगभग 1.5 सेकंड बाद चेतावनी देती है
एक बार में 43 स्टड से ज़्यादा टेलीपोर्ट करता हैअगली जाँच पर चेतावनी देती है
38 स्टड प्रति सेकंड तक की स्पीड से दौड़ता है, स्प्रिंट से लगभग डेढ़ गुना तेज़कुछ नहीं: 38.5 स्टड प्रति सेकंड से नीचे बाल्टी उतनी ही तेज़ी से ख़ाली होती है जितनी भरती है
अनंत स्टैमिना के लिए अपना MovementConfig बदलता हैकुछ नहीं: 26 स्टड प्रति सेकंड पर स्प्रिंट जितनी देर चाहें इजाज़त है
उड़ता है, बिना सीमा कूदता है या दीवारों के आर-पार जाता हैकुछ नहीं: जाँच ऊँचाई नज़रअंदाज़ करती है और टक्कर नहीं देखती

यानी जाँच मोटे चीट पकड़ती है, जिनमें प्लेयर साफ़ तौर पर बाकी सबसे तेज़ है, और सावधान चीट छोड़ देती है। यह दूरी वाली जाँच की ईमानदार सीमा है, और यही वजह है कि Roblox कुछ ज़्यादा मज़बूत बना रहा है (नीचे server authority देखें)।

यह सिर्फ़ चेतावनी क्यों देती है

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

Respawn और टेलीपोर्ट

Respawn नया root पार्ट बनाता है, और स्क्रिप्ट उसे देखते ही फिर से मापना शुरू करती है, इसलिए स्पॉन पॉइंट से दूर मरना कभी स्पीड से ज़्यादा नहीं गिना जाता। आपकी अपनी सर्वर स्क्रिप्ट के टेलीपोर्ट को छूट चाहिए, जैसा Roblox डॉक्यूमेंटेशन टेलीपोर्ट वाले हर गेम के लिए कहता है। टेलीपोर्ट के बाद player:SetAttribute("MovementCheckSkip", true) जोड़ें, और अगली जाँच झटके को पकड़ने की जगह नई पोज़िशन से मापना शुरू करेगी:

टेलीपोर्ट गाइड के पैड और मेनू और पहले गेम वाली गाइड का Finish पैड पहले से हर हलचल के बाद इसे सेट करते हैं।

सिर्फ़ सर्वर का मान गिना जाता है। प्लेयर अपने डिवाइस पर जो attribute सेट करता है, वह उसी डिवाइस पर रहता है (देखें क्या replicate होता है और क्या नहीं), इसलिए चीटर इससे जाँच बंद नहीं कर सकता।

भविष्य का हल: server authority

Roblox की सुरक्षा डॉक्यूमेंटेशन server authority मॉडल को, जो लिखते समय बीटा में है, मूवमेंट exploit रोकने का सबसे भरोसेमंद तरीका बताती है। सच का स्रोत सर्वर बनता है, और प्लेयर के डिवाइस सिर्फ़ अपना इनपुट बताते हैं, जो डॉक्यूमेंटेशन के अनुसार स्पीड हैक को काम नहीं करने देता, क्योंकि डिवाइस पर कभी अपनी पोज़िशन बताने का भरोसा नहीं किया जाता।

यह बदलाव दोबारा लिखना है, सेटिंग नहीं। इस मॉडल में हलचल सर्वर गिनता है, इसलिए सिर्फ़ LocalScript का सेट किया WalkSpeed या LinearVelocity सर्वर से स्थिति आने पर रद्द हो जाता है। Roblox डॉक्यूमेंटेशन कहती है कि मुख्य लॉजिक एक ModuleScript में RunService:BindToSimulation() फ़ंक्शन में चलना चाहिए, जिसे क्लाइंट और सर्वर दोनों चलाते हैं। मॉडल को Workspace की कुछ सेटिंग भी चाहिए, PlayerScriptsUseInputActionSystem समेत, इसलिए आपका कंट्रोल भी Input Action System पर जाएगा। जब तक आप स्प्रिंट, स्टैमिना और डैश इस ढाँचे में नहीं ले जाते, इस गाइड का वर्ज़न रखें। तब तक इस तरह की दूरी वाली जाँच ही वह है जो मूवमेंट जाँच पर Roblox का सेक्शन बताता है।

स्टेप 6: हर डिवाइस पर जाँचें

  1. Play दबाएँ और चलते समय Shift दबाए रखें। स्पीड 16 से 26 स्टड प्रति सेकंड हो जाती है, और स्क्रीन के नीचे हरा बार घटता है। लगभग 5 सेकंड बाद वह ख़ाली है, और आप फिर पैदल चलते हैं।
  2. Shift छोड़ें। 1 सेकंड बाद बार भरने लगता है। जब तक वह पाँचवाँ हिस्सा न भर जाए, Shift कुछ नहीं करता।
  3. चलते समय Q दबाएँ: आप थोड़ा आगे झपटते हैं, और बार का चौथाई चला जाता है। तुरंत फिर Q दबाएँ, और एक सेकंड बीतने तक कुछ नहीं होगा। अगर डैश बहुत छोटा या लंबा लगे, तो MovementConfig में DASH_SPEED या DASH_SECONDS बदलें।
  4. जंप करें, फिर दूसरे जंप के लिए हवा में फिर जंप दबाएँ। उतरें और फिर कोशिश करें: ज़मीन से हर जंप हवा का जंप लौटा देता है।
  5. पूरे जंप के दौरान Space दबाए रखें। एक ही जंप होना चाहिए, दो नहीं, क्योंकि हवा के जंप को नया दबाना चाहिए।
  6. Studio में Device Simulator चालू करें (लिखते समय यह बीटा है: File, Beta Features, New Device Simulator, फिर Studio रीस्टार्ट करें) या Test मेनू में पुराना Device Emulator चालू करें। एक फ़ोन चुनें और Play दबाएँ। Sprint और Dash बटन दिखेंगे। दिशा देते समय Sprint दबाए रखें, फिर पूरे जंप में जंप बटन दबाए रखें और जाँचें कि जंप एक ही है।
  7. Controller Emulator खोलें (Emulation टैब पर Controller या Device Simulator पैनल पर Virtual controller)। दौड़ने के लिए चलते समय L3 दबाए रखें, डैश के लिए B और डबल जंप के लिए A दो बार दबाएँ।
  8. गेम मेनू से कैरेक्टर रीसेट करें। बार फिर पूरा है, Output में MovementCheck की कोई चेतावनी नहीं है, और अगर आप अब भी फ़ोन simulate कर रहे हैं, तो Sprint और Dash बटन अपनी जगह हैं।
  9. अब चीटर बनकर खेलें। Client/Server स्विच तब तक दबाएँ जब तक Explorer क्लाइंट न दिखाए, Workspace में अपने कैरेक्टर का Humanoid चुनें और Properties विंडो में WalkSpeed को 60 करें। कुछ सेकंड चलें: Output में MovementCheck: YourName moved 60 studs/s जैसी चेतावनी आएगी। 16 वापस करें, फिर एक मिनट सामान्य रूप से दौड़ें और डैश करें और जाँचें कि Output चुप है।
  10. अगर आपके place में Workspace.PlayerScriptsUseInputActionSystem Enabled पर है, तो डबल जंप फिर से जाँचें: Roblox डॉक्यूमेंटेशन नहीं बताती कि इसके साथ JumpRequest वैसा ही व्यवहार करता है या नहीं।

अगर कुछ भी नहीं होता, तो Studio में Window मेनू से Output विंडो खोलें और MovementClient की लाल गलती ढूँढें, या आम गलतियाँ देखें।

कितना तेज़ और कितनी देर: गेम के प्रकार के हिसाब से प्रीसेट

सही स्प्रिंट गेम पर निर्भर करता है। हॉरर में पीछा करने के लिए छोटा, धीमा स्प्रिंट चाहिए जो सबसे बुरे पल में ख़त्म हो; बड़े ओपन मैप के लिए लंबा, ताकि प्लेयर उसे पार करते हुए बोर न हों। ये प्रीसेट वही स्क्रिप्ट इस्तेमाल करते हैं और सिर्फ़ चलने की स्पीड और MovementConfig बदलते हैं। ये हमारे शुरुआती बिंदु हैं, सेटिंग से गिने गए, प्लेयर पर मापे नहीं गए।

गेम के प्रकार के हिसाब से चलने की स्पीड, स्प्रिंट और स्टैमिना। स्प्रिंट का समय MAX_STAMINA / DRAIN_PER_SECOND है; भरना MAX_STAMINA / REGEN_PER_SECOND और REGEN_DELAY का 1 सेकंड है
गेम का प्रकारCharacterWalkSpeedSPRINT_BONUS (स्प्रिंट स्पीड)DRAIN_PER_SECONDREGEN_PER_SECONDपूरा स्प्रिंटख़ाली से पूराएक बार में दूरी
यह गाइड1610 (26)20155 सेकंड7.7 सेकंड130 स्टड
हॉरर में पीछा128 (20)25104 सेकंड11 सेकंड80 स्टड
बैटलग्राउंड और फ़ाइटिंग1612 (28)15206.7 सेकंड6 सेकंडलगभग 187 स्टड
ओपन वर्ल्ड या सिम्युलेटर1616 (32)102510 सेकंड5 सेकंड320 स्टड
Obby या पार्कौर168 (24)बिना स्टैमिना: ShiftToSprint इस्तेमाल करें
  • चलने की स्पीड StarterPlayer में सेट होती है। StarterPlayer चुनें और CharacterWalkSpeed सेट करें (डिफ़ॉल्ट 16)। हर नया कैरेक्टर इसी स्पीड से शुरू होता है, स्प्रिंट इसमें SPRINT_BONUS जोड़ता है, और MovementCheck भी इसे पढ़ती है, इसलिए सर्वर जाँच आपकी पसंद के साथ चलती है।
  • MovementCheck अपने आप ढलती है। वह चलने की स्पीड, स्प्रिंट बोनस और लैग के लिए एक चौथाई और की इजाज़त देती है: हॉरर प्रीसेट के लिए 25 स्टड प्रति सेकंड, ओपन वर्ल्ड के लिए 40। और कुछ बदलने की ज़रूरत नहीं।
  • Obby में स्प्रिंट ट्रैक बदल देता है। तेज़ स्प्रिंट से लंबी खाइयाँ पार हो जाती हैं। जंप बनाएँ, फिर हर एक को स्प्रिंट स्पीड पर जाँचें, वरना स्प्रिंट स्टेज बहुत आसान कर देगा। obby चेकपॉइंट गाइड ShiftToSprint के साथ अच्छी चलती है।
  • हॉरर में पैमाना क़ातिल है। पीछा करने वाले को चलने की स्पीड से थोड़ा तेज़ और स्प्रिंट से थोड़ा धीमा बनाएँ, ताकि बचना इस पर निर्भर करे कि बार कब ख़त्म होता है। हॉरर गेम गाइड बाकी लूप समझाती है।

पुरानी स्प्रिंट स्क्रिप्ट में क्या गड़बड़ है

स्प्रिंट, डैश और डबल जंप के पुराने ट्यूटोरियल अक्सर अब भी काम करते हैं, लेकिन कई ऐसी तरकीबें इस्तेमाल करते हैं जिन्हें Roblox ने तब से बदल दिया है, या आपके गेम के दूसरे सिस्टम तोड़ देते हैं। अगर आप कॉपी की हुई स्क्रिप्ट ठीक कर रहे हैं, तो उसे इस लिस्ट से मिलाएँ।

पुराने ट्यूटोरियल की तरकीबें और उनकी जगह यह गाइड क्या करती है
तरकीबसमस्या क्या हैयह गाइड
डैश के लिए BodyVelocityDeprecated: Roblox उसकी जगह LinearVelocity इस्तेमाल करने को कहता हैPlane मोड में LinearVelocity
RunService.RenderStepped पर लूपनए काम के लिए इसकी जगह PreRender ने ली है। स्टैमिना जैसे गेम लॉजिक की जगह Heartbeat पर है, जिसे Roblox हेल्थ भरने जैसे नियमित कामों के लिए बताता हैdeltaTime के साथ Heartbeat
wait() पर स्टैमिना लूपwait() को task.wait() के पक्ष में deprecated किया गया है और यह धीमा किया जाता है, इसलिए माँगे से ज़्यादा इंतज़ार कर सकता है, और हर wait पर तय ख़र्च स्टैमिना असमान रूप से घटाता हैdeltaTime के हिसाब से हर फ़्रेम ख़र्च और भरना
चैट जाँच के बिना UserInputService.InputBeganचैट में संदेश लिखते समय Shift दबाने से स्प्रिंट शुरू हो जाता हैContextActionService, जो फ़ोन पर बटन भी जोड़ता है
छोड़ने पर या हर फ़्रेम WalkSpeed = 16किसी भी दूसरी स्पीड को ओवरराइट करता है, जैसे गेमपास perkWalkSpeed सिर्फ़ स्प्रिंट की शुरुआत और अंत में बदलती है, मौजूदा मान में जोड़कर
RemoteEvent से स्प्रिंट, ताकि WalkSpeed सर्वर सेट करेExploiter फिर भी अपना WalkSpeed ख़ुद सेट करते हैं, और स्प्रिंट आने-जाने की देरी से शुरू होता हैक्लाइंट पर स्प्रिंट और सर्वर पर दूरी की जाँच
हर JumpRequest पर डबल जंपJumpRequest एक जंप अनुरोध पर कई बार चलता है, और दबाए रखा बटन जंप माँगता रह सकता है0.25 सेकंड का विराम और नए दबाने की जाँच
«यह फ़ोन है» जाँचने के लिए UserInputService.TouchEnabledटच स्क्रीन वाले लैपटॉप पर यह true होता हैContextActionService आपकी अपनी डिवाइस जाँच के बिना टच डिवाइस पर स्क्रीन पर बटन जोड़ता है
रन ऐनिमेशन के लिए Humanoid:LoadAnimationAnimator:LoadAnimation के पक्ष में deprecatedनीचे रन ऐनिमेशन Animator इस्तेमाल करता है

Roblox का नया तरीका: Input Action System

Input Action System पर Roblox का पेज पहले उदाहरण के रूप में कैरेक्टर स्प्रिंट लेता है। BindAction कॉल की जगह कंट्रोल Studio में सेट होते हैं: ReplicatedStorage में एक input context के अंदर CharacterSprint नाम का InputAction, जिसमें एक InputBinding Left Shift के लिए, एक गेमपैड के Y बटन के लिए और एक स्क्रीन के उस बटन से जुड़ा जिसे आप StarterGui में बनाते हैं। फिर क्लाइंट स्क्रिप्ट ऐक्शन के Pressed और Released इवेंट सुनती है, दबाने पर WalkSpeed दोगुनी करती है और छोड़ने पर वापस करती है।

इस पर जाना तब ठीक है जब आप कंट्रोल कोड की जगह Studio में सजाना चाहते हैं, ContextActionService के बटन की जगह अपना टच बटन चाहते हैं, या ऐसे context चाहते हैं जो कंट्रोल के पूरे सेट बदलें, जैसे मेनू या गाड़ी के लिए। पेज Workspace.PlayerScriptsUseInputActionSystem को Enabled करने की भी सलाह देता है, और server authority इसे ज़रूरी बनाता है।

इस गाइड का स्टैमिना लूप और डैश अकेले Input Action System के साथ (बिना server authority) वैसे ही काम करते हैं। MovementConfig, Heartbeat लूप और dash() रखें, दोनों BindAction कॉल और उनके हैंडलर हटाएँ, और उनकी जगह ऐक्शन जोड़ें: स्प्रिंट ऐक्शन का Pressed sprintHeld को true करता है, और उसका Released false, और डैश ऐक्शन का Pressed dash() कॉल करता है। MovementClient की तरह हर फ़्रेम Humanoid ढूँढते रहें, क्योंकि डॉक्यूमेंटेशन का उदाहरण पहले कैरेक्टर का Humanoid रख लेता है, और respawn के बाद वह नहीं रहता।

Roblox Character Controller Library भी टेस्ट कर रहा है, एक बीटा जिसे Studio में Beta Features और Avatar Settings में चालू किया जाता है। उसकी क्षमताओं वाला पेज उदाहरण के रूप में 0.2 सेकंड की सक्रिय विंडो और 1 सेकंड के cooldown वाला डैश बनाता है, यानी इस गाइड के डैश जैसी ही टाइमिंग।

कैसे बढ़ाएँ: ऐनिमेशन, कैमरा और स्प्रिंट पास

रन ऐनिमेशन

Animation Editor में रन ऐनिमेशन बनाएँ, उसे Movement प्राथमिकता दें (Roblox चलने और दौड़ने के ऐनिमेशन के लिए इसे सुझाता है), पब्लिश करें और asset ID कॉपी करें। MovementClient में इस AnimationId के साथ एक Animation बनाएँ, कैरेक्टर के Humanoid के अंदर के Animator से उसे Animator:LoadAnimation से लोड करें, जहाँ स्प्रिंट शुरू होता है वहाँ ट्रैक चलाएँ और जहाँ ख़त्म होता है वहाँ रोकें। हर नए कैरेक्टर के लिए उसे फिर से लोड करें।

आपका डिवाइस आपके कैरेक्टर पर जो ऐनिमेशन चलाता है, उन्हें सब देखते हैं, अगर आप वह Animator इस्तेमाल करते हैं जिसे Roblox ने वहाँ रखा: LocalScript के बनाए Animator पर लोड किए गए ट्रैक replicate नहीं होते। Humanoid:LoadAnimation, जिसे कई पुराने ट्यूटोरियल इस्तेमाल करते हैं, deprecated है।

स्प्रिंट के दौरान चौड़ा कैमरा

थोड़ा चौड़ा देखने का कोण स्प्रिंट को महसूस में तेज़ बनाता है। उन्हीं दो जगहों पर स्प्रिंट शुरू होने पर workspace.CurrentCamera.FieldOfView को डिफ़ॉल्ट 70 से लगभग 80 तक ट्वीन करें, और ख़त्म होने पर वापस, जैसे TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play() से। Roblox मान को 1 से 120 के बीच सीमित करता है और चेतावनी देता है कि बहुत कम या बहुत ज़्यादा मान प्लेयर को भ्रमित कर सकते हैं। अगर गेम की कोई और स्क्रिप्ट भी देखने का कोण बदलती है, तो 70 की जगह मिले हुए मान पर वापस ट्वीन करें।

गेमपास के रूप में तेज़ स्प्रिंट

गेमपास गाइड पहले से इस स्क्रिप्ट के साथ काम करती है: उसका Speed perk सर्वर पर हर नए कैरेक्टर का WalkSpeed 24 करता है, MovementClient ऊपर से स्प्रिंट बोनस जोड़ती है, और 34 स्टड प्रति सेकंड MovementCheck की इजाज़त के भीतर रहता है।

जो पास स्प्रिंट को ही तेज़ करे, उसके लिए उस गाइड के PassConfig.ids में FastSprint पास जोड़ें। तब उसकी सर्वर स्क्रिप्ट ख़रीदारी की पुष्टि होते ही प्लेयर पर OwnsPass_FastSprint attribute सेट करती है। MovementClient में जब player:GetAttribute("OwnsPass_FastSprint") == true हो, तो Config.SPRINT_BONUS से बड़ा बोनस इस्तेमाल करें। MovementCheck में ऐसे प्लेयर को बड़ी छूट दें, यही attribute सर्वर पर पढ़कर, जहाँ प्लेयर उसे बदल नहीं सकता, और जाँचें कि नई सबसे ज़्यादा स्पीड उससे नीचे रहे जिसे जाँच पकड़ती है।

एक सीमा जो जानना अच्छा है: अगर कोई दूसरी स्क्रिप्ट स्प्रिंट के बीच WalkSpeed बदलती है, तो उस स्प्रिंट का अंत वही स्पीड लौटाएगा जो उससे पहले थी। अगला respawn पास की स्पीड फिर से सेट करेगा, क्योंकि गेमपास स्क्रिप्ट उसे हर नए कैरेक्टर पर लगाती है।

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

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

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

MovementClient या MovementCheck ऐसे मॉड्यूल का इंतज़ार कर रही है जो ठीक इस नाम से नहीं है। यह ReplicatedStorage के ठीक अंदर MovementConfig नाम का ModuleScript होना चाहिए। स्क्रिप्ट गलतियों वाली गाइड इस चेतावनी को विस्तार से समझाती है।

Shift कुछ नहीं करता

जाँचें कि ShiftToSprint या MovementClient एक LocalScript है, Script नहीं, और StarterPlayerScripts में है। MovementClient के साथ स्प्रिंट शुरू करने के लिए कैरेक्टर को चलना भी चाहिए और कम से कम 20 स्टैमिना होनी चाहिए, इसलिए चलते समय Shift दबाए रखें। अगर स्प्रिंट की जगह Shift Lock बदलता है, तो नीचे Shift Lock वाला सवाल देखें।

स्प्रिंट कुछ सेकंड बाद रुक जाता है

यह स्टैमिना ख़त्म होना है: 20 प्रति सेकंड पर 100 स्टैमिना 5 सेकंड चलती है। MovementConfig में MAX_STAMINA बढ़ाएँ या DRAIN_PER_SECOND घटाएँ।

डैश कुछ नहीं करता

डैश को 25 स्टैमिना चाहिए, वह पिछले के 1 सेकंड बाद तक रुकता है और बैठे रहने पर कुछ नहीं करता। अगर बात यह नहीं है, तो आपके कैरेक्टर के root पार्ट में RootAttachment नाम का Attachment शायद नहीं है, जो कुछ अपने कैरेक्टर के साथ होता है: उसे अपने StarterCharacter के HumanoidRootPart में जोड़ें।

डबल जंप नहीं होता

DoubleJump, StarterCharacterScripts में LocalScript होनी चाहिए, StarterPlayerScripts में नहीं, क्योंकि वह script.Parent को कैरेक्टर मानती है। ज़मीन छोड़ने के बाद दूसरी बार जंप दबाएँ: दबाए रखा बटन नया दबाना नहीं गिना जाता, और किनारे से उतरने पर हवा का जंप नहीं मिलता।

फ़ोन पर Sprint या Dash बटन नहीं है

ContextActionService अपने बटन सिर्फ़ टच डिवाइस पर जोड़ता है, इसलिए बिना टच स्क्रीन वाले PC पर वे कभी नहीं दिखते। Studio के Device Simulator में फ़ोन के साथ जाँचें (यह बीटा है: File, Beta Features में New Device Simulator चालू करें और Studio रीस्टार्ट करें)। BindAction 7 से ज़्यादा टच बटन नहीं बना सकता, इसलिए गिनें कि गेम की दूसरी स्क्रिप्ट कितने बनाती हैं।

MovementCheck ईमानदार प्लेयर पर चेतावनी देती है

आम वजहें: किसी दूसरी सर्वर स्क्रिप्ट से टेलीपोर्ट, कन्वेयर या गाड़ी, या लैग। अपने टेलीपोर्ट के बाद MovementCheckSkip attribute सेट करें (देखें Respawn और टेलीपोर्ट) और अगर जाँच सामान्य खेल में भी चलती है, तो SPEED_ALLOWANCE बढ़ाएँ।

स्प्रिंट के बाद स्पीड बूस्ट ग़ायब हो जाता है

किसी दूसरी स्क्रिप्ट ने स्प्रिंट के दौरान WalkSpeed बदली, और ख़त्म होने पर स्प्रिंट ने वह स्पीड लौटा दी जो उसने शुरुआत में देखी थी। बूस्ट कैरेक्टर के स्पॉन पर दें, जैसे गेमपास गाइड करती है, ताकि respawn फिर से सही स्पीड सेट करे।

RoCode से बनाएँ

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

आप लिखते हैं

स्टैमिना बार के साथ Shift से स्प्रिंट जोड़ो: Shift दबे रहने तक चलने की स्पीड प्लस 10, 100 स्टैमिना, 20 प्रति सेकंड ख़र्च, एक सेकंड आराम के बाद 15 प्रति सेकंड भरना, फ़ोन पर Sprint बटन, Q पर डैश और डबल जंप।

RoCode करता है
  • पहले Search Scripts और Read Script से आपका place देख सकता है, ताकि WalkSpeed बदलने वाली दूसरी स्क्रिप्ट (जैसे गेमपास perk) ढूँढे, और स्प्रिंट उनमें जुड़े
  • Create Script से ModuleScript, LocalScript और सर्वर जाँच लिखता है
  • उसे अपनी लिखी हर स्क्रिप्ट का कंपाइल Check Script से जाँचने को कहा गया है, जो उसे Studio में बिना चलाए कंपाइल करता है
  • बदलावों के हर बैच से पहले और बाद में undo पॉइंट रखता है, इसलिए Ctrl+Z एक बार में एक बैच वापस करता है

RoCode रन ऐनिमेशन नहीं बना सकता: उसे Animation Editor में बनाएँ और उसकी ID डालें। प्लगइन 3.9.11 या नए के साथ RoCode Studio में आपके गेम का playtest चला सकता है और सब कुछ काम करता है यह जाँचने के लिए टेस्ट कैरेक्टर चला सकता है, और प्लगइन 3.9.15 या नए के साथ टेस्ट कैरेक्टर कुंजियाँ दबा सकता है, जैसे Shift दबाए रखकर जाँचना कि WalkSpeed बढ़ी। वह ख़ुद तय करता है कि playtest कब चलाना है, हर बिल्ड में 2 तक और अपने सुधार की जाँच के लिए 1, और सिर्फ़ वही जाँचता है जो उसने ख़ुद टेस्ट करने का फ़ैसला किया, इसलिए स्प्रिंट, डैश और डबल जंप ख़ुद आज़माएँ, और फ़ोन के बटन Studio के Device Simulator में जाँचें। मूवमेंट गेम के कई सिस्टम में से एक है; RoCode के साथ पूरा गेम बनाना यहाँ की तरह हर प्रॉम्प्ट में एक सिस्टम से चलता है। RoCode, Studio से कैसे जुड़ता है।

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

स्प्रिंट स्क्रिप्ट फ़ोन पर काम क्यों नहीं करती?

फ़ोन में Shift कुंजी नहीं होती। स्प्रिंट को ContextActionService:BindAction से बाँधें और तीसरे आर्ग्युमेंट के रूप में true दें: यह टच डिवाइस पर स्क्रीन पर बटन जोड़ता है, जैसे ShiftToSprint और MovementClient दोनों करती हैं।

क्या स्प्रिंट सर्वर पर बनाना चाहिए?

नहीं। हर डिवाइस अपने कैरेक्टर को चलाता है, इसलिए सर्वर का सेट किया WalkSpeed उस चीटर को नहीं रोकेगा जो अपना ख़ुद सेट कर सकता है, और नई स्पीड आने-जाने के बाद ही आती है, इसलिए स्प्रिंट देरी से शुरू होता है। स्प्रिंट क्लाइंट पर बनाएँ, और सर्वर पर जाँचें कि कैरेक्टर असल में कितनी दूर जाते हैं, जैसे स्टेप 5 में। Roblox का server authority बीटा अलग तरह से बना है, और उसके लिए मूवमेंट कोड दोबारा लिखना होगा।

Shift छोड़ने के बाद भी कैरेक्टर दौड़ता क्यों रहता है?

स्क्रिप्ट ने छोड़ना मिस कर दिया, आमतौर पर इसलिए कि वह सिर्फ़ दबाना सुनती है। ContextActionService कुंजी छोड़ने पर End और किसी दूसरी binding के ले लेने पर Cancel भेजता है; MovementClient दोनों पर रुकती है, और तब भी जब स्टैमिना ख़त्म हो या कैरेक्टर चलना बंद करे।

रन ऐनिमेशन कैसे जोड़ें?

उसी LocalScript में कैरेक्टर के Humanoid के Animator से रन ऐनिमेशन लोड करें, स्प्रिंट शुरू होने पर चलाएँ और ख़त्म होने पर रोकें। उसे Movement प्राथमिकता दें। आपके अपने कैरेक्टर पर चलाए ऐनिमेशन सब देखते हैं।

फ़ोन पर डबल जंप अपने आप क्यों हो जाता है?

फ़ोन पर दबाए रखा जंप बटन जंप माँगता रहता है। जंप को नया तभी मानें जब अनुरोध एक पल के लिए रुक गए हों, जैसे DoubleJump स्क्रिप्ट करती है।

Roblox में डिफ़ॉल्ट चलने की स्पीड कितनी है?

16 स्टड प्रति सेकंड। यह StarterPlayer.CharacterWalkSpeed से आती है, जो हर नए कैरेक्टर का Humanoid.WalkSpeed सेट करता है। इस गाइड का स्प्रिंट 10 जोड़ता है, इसलिए स्प्रिंट 26 पर होता है।

Roblox में स्प्रिंट की स्पीड कितनी होनी चाहिए?

ज़्यादातर गेम चलने की स्पीड का आधा से पूरा हिस्सा जोड़ते हैं: 16 कुछ 24 से 32 के बीच बन जाता है। छोटा, धीमा स्प्रिंट हॉरर के लिए ठीक है, और लंबा, तेज़ बड़े मैप के लिए। गेम के प्रकार के हिसाब से प्रीसेट हर एक के लिए चलने की स्पीड, स्प्रिंट बोनस और स्टैमिना के नंबर देते हैं।

स्टैमिना वाला स्प्रिंट कैसे बनाएं?

स्टैमिना का नंबर प्लेयर के डिवाइस पर रखें, स्प्रिंट के दौरान हर फ़्रेम उसे ख़र्च करें और थोड़े आराम के बाद भरें, दोनों बार फ़्रेम के समय के हिसाब से, और 0 पर पहुँचने पर स्प्रिंट रोकें। स्टेप 3 की MovementClient स्क्रीन पर बार के साथ यही करती है; नंबर MovementConfig में हैं।

Roblox में कंट्रोलर से स्प्रिंट कैसे करें?

गेमपैड का ButtonL3 (बाएँ स्टिक को दबाना) ContextActionService से Left Shift के साथ बाँधें, जैसे यहाँ की दोनों स्क्रिप्ट करती हैं। ShiftToSprint, L3 को टॉगल बनाती है, क्योंकि स्टिक दबाए रखते हुए उसी से दिशा देना थकाऊ है।

क्या Shift से स्प्रिंट Shift Lock से टकराता है?

हो सकता है। जिन प्लेयर ने Roblox सेटिंग में Shift Lock चालू किया है, वे उसे Shift कुंजी से बदलते हैं, इसलिए एक कुंजी दो काम करती है। Roblox डॉक्यूमेंटेशन कहती है कि Shift Lock API हटाए जा रहे हैं। अगर यह टकराव आपके प्लेयर को परेशान करता है, तो StarterPlayer.EnableMouseLockOption बंद करें या MovementClient में स्प्रिंट को किसी दूसरी कुंजी से बाँधें, जैसे Left Ctrl।

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

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

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

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