Tutorial · Sistem permainan

Cara buat lari dengan Shift dalam Roblox Studio untuk PC, telefon dan konsol

Lari dengan Shift dalam Roblox bergantung pada satu nombor: WalkSpeed pada Humanoid, yang naik selagi Shift ditekan. Langkah 1 membuat tepat itu dalam satu LocalScript pendek, yang turut berfungsi dengan butang Sprint pada telefon dan dengan gamepad. Selebihnya panduan ini menambah apa yang diperlukan oleh game besar: bar stamina, dash dengan fizik moden, lompat berganda yang tidak tercetus apabila butang ditahan, dan kefahaman tentang apa yang boleh disemak oleh pelayan dan apa yang tidak.

Dikemas kini 20 November 202624 minit bacaanDitulis oleh

Ringkasnya

Letakkan satu LocalScript dalam StarterPlayerScripts yang mengikat tindakan Sprint melalui ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Selagi Shift ditekan, tambah 10 pada Humanoid.WalkSpeed (16 menjadi 26), dan apabila dilepaskan, kembalikan nilai sebelumnya. Argumen true menambah butang Sprint pada skrin sentuh, dan dalam skrip panduan ini butang itu serta L3 pada gamepad menghidupkan dan mematikan larian, bukan berfungsi secara tahan.

  • Tambah pada WalkSpeed semasa, jangan tetapkan 26, supaya kelajuan tambahan daripada game pass kekal.
  • Larian berjalan pada peranti pemain. Pelayan tidak boleh memaksa WalkSpeed; ia hanya boleh mengukur sejauh mana watak bergerak dan menandakan kelajuan yang tidak dapat dijelaskan oleh larian.
  • Bar stamina, dash dan lompat berganda berdasarkan idea yang sama ditambah dalam Langkah 2 hingga 4. Berapa laju dan berapa lama untuk berlari, lihat pratetap mengikut jenis game dengan nombor untuk game seram, pertarungan dan dunia terbuka.
Di halaman ini
  1. Cara ia berfungsi
  2. 1. Lari dengan Shift
  3. 2. Modul tetapan
  4. 3. Larian dan dash
  5. 4. Lompat berganda
  6. 5. Semakan pelayan
  7. 6. Ujian
  8. Pratetap kelajuan
  9. Skrip lama
  10. Input Action System
  11. Pengembangan
  12. Common errors
  13. Dengan RoCode
  14. Soalan lazim
  15. Sumber dan bacaan lanjut

Cara larian berfungsi dalam Roblox

IlustrasiShift memberi larian dengan WalkSpeed 26 sementara bar berkurang, Q membuat dash dengan suku bar, dan tekanan lompat kedua di udara melompat sekali lagi.

Peranti setiap pemain menggerakkan wataknya sendiri. Papan kekunci, alat kawalan atau skrin sentuh menentukan ke mana watak pergi, dan Roblox menghantar hasilnya kepada pelayan dan semua orang lain. Sebab itu larian ialah LocalScript yang menaikkan Humanoid.WalkSpeed selagi kekunci ditekan, dan itu sahaja yang dibuat oleh Langkah 1. Selebihnya panduan ini ialah apa yang diperlukan oleh game besar di sekelilingnya: bar stamina, dash, lompat berganda dan semakan pelayan untuk penipu.

Apa yang membentuk sistem pergerakan
ElemenDi mana ia beradaApa yang dibuat
LocalScript ShiftToSprintStarterPlayerScriptsLangkah 1 secara bersendirian: larian pada papan kekunci, telefon dan gamepad, tanpa stamina. Apabila anda menambah stamina dan dash, MovementClient menggantikannya.
ModuleScript MovementConfigReplicatedStorageNombor: bonus larian, stamina dan dash. Ia dibaca oleh LocalScript dan oleh semakan pelayan.
LocalScript MovementClientStarterPlayerScriptsMengikat Sprint dan Dash pada kekunci, butang gamepad dan butang sentuh, menjalankan kitaran stamina, melukis bar dan membuat dash.
LocalScript DoubleJumpStarterCharacterScriptsMemberi satu lompatan tambahan di udara. Salinan baharu berjalan dalam setiap watak baharu.
Script MovementCheckServerScriptServiceMengukur sejauh mana setiap watak sebenarnya bergerak, dan menulis amaran dalam Output apabila seseorang bergerak lebih laju daripada yang dibenarkan oleh larian dan dash untuk tempoh yang lama.
Explorer apabila sistem pergerakan sudah siap
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Jika perbezaan antara Script dan LocalScript masih baharu bagi anda, Script, LocalScript dan ModuleScript menerangkan di mana setiap jenis berjalan dan kenapa.

Langkah 1: lari dengan Shift dalam satu LocalScript

Jika anda hanya mahu larian lebih laju selagi Shift ditekan, satu skrip ini sudah cukup. Ia juga memberi telefon butang Sprint pada skrin, dan pada gamepad membolehkan anda berlari dengan analog kiri.

  1. Dalam Explorer, kembangkan StarterPlayer, halakan tetikus pada StarterPlayerScripts, tekan butang + dan masukkan LocalScript bernama ShiftToSprint.
  2. Gantikan kandungannya dengan kod di bawah dan tekan Play.
LocalScript dalam StarterPlayerScripts bernama ShiftToSprint
-- LocalScript dalam StarterPlayer > StarterPlayerScripts bernama ShiftToSprint.
-- Tahan Left Shift untuk berlari. Pada gamepad, tekan analog kiri (L3) untuk
-- menghidupkan atau mematikan larian. Pada telefon, tekan butang Sprint untuk menghidupkan atau mematikannya.

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

-- Tetapan
local SPRINT_BONUS = 10 -- ditambah pada WalkSpeed semasa berlari (16 menjadi 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: butang perlu ditahan

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- WalkSpeed untuk dikembalikan

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
		-- Ingat kelajuan semasa dan tambah padanya, supaya kelajuan tambahan daripada skrip lain kekal
		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
		-- Tahan: berlari selagi kekunci atau butang ditekan
		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
		-- Togol: setiap tekanan menghidupkan atau mematikan larian
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Satu panggilan mengikat kekunci, butang gamepad dan, pada skrin sentuh, butang pada skrin
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- Watak baharu bermula dengan berjalan: Humanoidnya sudah ada WalkSpeed biasa
player.CharacterAdded:Connect(function()
	sprinting = false
end)

Ubah SPRINT_BONUS untuk menjadikan larian lebih laju atau perlahan. Tetapkan TOGGLE_ON_TOUCH_AND_GAMEPAD kepada false supaya butang telefon dan L3 berfungsi seperti Shift: berlari hanya selagi ditekan.

BindAction mengikat satu tindakan pada Left Shift dan pada butang L3 gamepad, dan argumen ketiganya, true, menambah butang pada skrin sentuh; SetTitle menulis "Sprint" padanya. Pengendali turut menerima input itu sendiri, jadi ia membezakan tekanan papan kekunci daripada gamepad atau butang sentuh. Apabila larian bermula, skrip mengingati WalkSpeed semasa dan menambah SPRINT_BONUS; apabila ia tamat, nilai yang diingati dikembalikan. Kelajuan yang ditetapkan oleh skrip lain, contohnya perk Speed daripada panduan game pass, kekal. Watak baharu bermula dengan WalkSpeed biasa, jadi pengendali CharacterAdded hanya menetapkan semula bendera.

Tahan atau togol?

Cara ShiftToSprint berfungsi pada setiap peranti apabila TOGGLE_ON_TOUCH_AND_GAMEPAD bernilai true
Peranti dan inputBerfungsi sebagaiKenapa
Papan kekunci: Left ShiftTahanMenahan kekunci sambil bergerak itu mudah, dan melepaskannya terus menghentikan larian.
Gamepad: tekan analog kiri (L3)TogolMenahan analog ditekan sambil mengemudi dengannya memenatkan.
Telefon atau tablet: butang Sprint pada skrinTogolIbu jari yang menahan butang tidak boleh menekan Jump pada masa yang sama.

Untuk menguji, tekan Play dan tahan Shift sambil berjalan: kelajuan naik dari 16 ke 26 stud sesaat, dan jika dilepaskan, anda menjadi perlahan. Untuk telefon, pilih telefon dalam Device Simulator dalam Studio, tekan Play dan tekan Sprint sekali untuk bermula dan sekali lagi untuk berhenti. Untuk gamepad, buka Controller Emulator semasa playtest dan tekan L3. Senarai penuh semakan mengikut peranti ada dalam Langkah 6.

Langkah 2 dan 3 menggantikan skrip ini dengan skrip lain yang ada bar stamina dan dash. Langkah 4 dan 5 menambah lompat berganda dan semakan pelayan, dan berfungsi dengan mana-mana daripada dua skrip itu.

Langkah 2: nombor stamina dan dash dalam satu modul

Untuk larian yang boleh habis, Langkah 2 dan 3 menukar ShiftToSprint kepada LocalScript yang lebih besar dengan bar stamina dan dash. Padam ShiftToSprint dahulu: kedua-dua skrip mengikat tindakan Sprint.

Semua nombor berada dalam satu ModuleScript, jadi rasa pergerakan dilaraskan di satu tempat. MovementClient membacanya pada peranti setiap pemain, dan MovementCheck membaca modul yang sama pada pelayan untuk mengetahui kelajuan larian dan dash yang sepatutnya.

  1. Dalam Explorer, halakan tetikus pada ReplicatedStorage, tekan butang + dan masukkan ModuleScript.
  2. Namakan semula kepada MovementConfig dan gantikan kandungannya dengan kod di bawah.
ModuleScript dalam ReplicatedStorage bernama MovementConfig
-- Satu set nombor untuk LocalScript pergerakan dan semakan kelajuan pada pelayan.

local MovementConfig = {
	SPRINT_BONUS = 10, -- ditambah pada WalkSpeed semasa: 16 (nilai lalai Roblox) menjadi 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 saat larian daripada bar penuh
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- saat selepas larian tamat sebelum stamina mula pulih
	MIN_TO_START = 20, -- stamina yang diperlukan untuk mula berlari, supaya bar kosong tidak berkelip

	DASH_SPEED = 60, -- stud sesaat semasa dash
	DASH_SECONDS = 0.2, -- jadi dash bergerak kira-kira 12 stud
	DASH_COST = 25, -- stamina
	DASH_COOLDOWN = 1,
}

return MovementConfig
Apa yang dibuat oleh setiap tetapan
TetapanNilaiKesan
SPRINT_BONUS10Ditambah pada WalkSpeed semasa berlari. WalkSpeed lalai dalam Roblox ialah 16, jadi larian bergerak pada 26 stud sesaat.
MAX_STAMINA100Bar penuh.
DRAIN_PER_SECOND20Bar penuh cukup untuk 5 saat larian.
REGEN_PER_SECOND15Bar kosong terisi dalam kira-kira 6.7 saat.
REGEN_DELAY1Saat rehat sebelum pemulihan bermula.
MIN_TO_START20Stamina yang diperlukan untuk mula berlari.
DASH_SPEED60Stud sesaat semasa dash.
DASH_SECONDS0.2Berapa lama dash berlangsung: kira-kira 12 stud pada 60 stud sesaat.
DASH_COST25Stamina bagi setiap dash.
DASH_COOLDOWN1Saat antara dash.

Setiap pihak menjalankan salinan modulnya sendiri (modul dijalankan sekali pada setiap pihak), jadi pemain yang mengubah nombor ini pada perantinya hanya mengubah salinannya sendiri. Tetapi di sini ia tidak melindungi apa-apa: perantinya memang menggerakkan wataknya, jadi ia boleh memberi diri sendiri stamina tanpa had, tidak kira apa yang ada dalam modul. Semakan pelayan dalam Langkah 5 dibina dengan mengambil kira perkara ini.

Langkah 3: larian dengan stamina dan dash

LocalScript ini membuat apa yang dirasai pemain. Ia mengikat Sprint dan Dash, melukis bar stamina, menjalankan kitaran stamina setiap frame dan membuat dash.

  1. Dalam Explorer, kembangkan StarterPlayer, halakan tetikus pada StarterPlayerScripts dan masukkan LocalScript bernama MovementClient.
  2. Gantikan kandungannya dengan kod di bawah.
LocalScript dalam StarterPlayerScripts bernama MovementClient
-- Tahan Shift (atau L3, atau butang Sprint pada telefon) untuk berlari selagi ada stamina.
-- Tekan Q (atau B, atau butang Dash) untuk dash ke arah pergerakan.

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 untuk dikembalikan apabila larian tamat
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Bar stamina: bingkai dengan isian yang lebarnya sama dengan stamina yang tinggal
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

-- Larian: di sini hanya bendera; gelung Heartbeat di bawah memutuskan setiap frame sama ada untuk berlari
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Hanya tekan dan lepas yang mengubahnya: jari yang meluncur pada butang sentuh menghantar 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()
	-- Tiada dash semasa duduk: watak yang duduk dikimpal pada tempat duduk, jadi ia akan menolak seluruh kenderaan
	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 -- jeda pemulihan, seperti yang dibuat oleh larian

	-- Dash ke arah pemain bergerak, atau ke arah dia menghadap jika berdiri diam
	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 dalam mod Plane mengekalkan kelajuan mendatar dan tidak mengganggu graviti
	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

-- Setiap panggilan mengikat kekunci, butang gamepad dan, pada peranti sentuh, butang pada skrin
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")

-- Setiap frame: guna stamina semasa berlari dan bergerak, pulihkan selepas rehat pendek
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

	-- Ubah WalkSpeed hanya pada permulaan dan penghujung larian, supaya kelajuan yang ditetapkan
	-- oleh skrip lain (contohnya pass kelajuan) kekal, dan larian ditambah padanya
	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)

-- Watak baharu bermula dengan stamina penuh dan tiada apa yang ditekan
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- Humanoid baharu bermula dengan WalkSpeed biasa
end)

Bar stamina dicipta dalam kod dengan ResetOnSpawn bernilai false, jadi ia kekal pada skrin selepas respawn, dan pengendali CharacterAdded di bahagian bawah mengisinya semula untuk setiap watak baharu. Baris type Config menerangkan apa yang dipulangkan oleh modul, supaya semakan jenis ketat menangkap salah ejaan nama tetapan; semasa bermain ia tidak mengubah apa-apa.

Papan kekunci, gamepad dan butang telefon dengan satu panggilan

ContextActionService:BindAction menerima nama tindakan, fungsi pengendali, sama ada perlu mencipta butang sentuh, dan kemudian input. Jika anda menghantar true sebagai argumen ketiga, ContextActionService menambah butang pada skrin peranti sentuh, di dalam ScreenGui bernama ContextActionGui dalam PlayerGui pemain. SetTitle menulis "Sprint" dan "Dash" pada butang itu. BindAction boleh mencipta tidak lebih daripada 7 butang sentuh, jadi perhatikan bilangannya jika skrip lain dalam game turut menggunakannya.

Pengendali menerima keadaan input: Begin apabila ditekan dan End apabila dilepaskan. onSprint hanya mengingati sama ada Sprint ditahan. Ia juga menganggap Cancel sebagai lepasan, yang dihantar ContextActionService apabila ikatan lain mengambil alih input, dan mengabaikan Change, yang mungkin dihantar oleh jari yang bergerak pada butang sentuh. Kedua-dua pengendali memulangkan Pass, jadi ikatan seterusnya pada kekunci yang sama juga menerima input.

Rujukan Roblox untuk ContextActionService mengesyorkannya berbanding UserInputService.InputBegan dalam kebanyakan kes. Contohnya: hon kereta pada H yang tidak patut berbunyi semasa pemain menaip dalam chat. Ikatan hanya tercetus selagi ia yang terakhir untuk input itu, jadi apabila chat mengambil papan kekunci, anda tidak perlu menyemak apa-apa. Input gamepad: ButtonL3 (tekan analog kiri, yang ditahan semasa bergerak) dan ButtonB. Contoh larian Roblox sendiri menggunakan ButtonY, jadi tukar KeyCode dalam BindAction jika itu lebih sesuai untuk game anda.

Kitaran stamina

RunService.Heartbeat tercetus setiap frame selepas langkah fizik dan menghantar deltaTime, bilangan saat sejak frame sebelumnya. Jika anda mendarabkan kadar penggunaan dan pemulihan dengannya, bar penuh bertahan 5 saat sama ada game berjalan pada 30 atau 240 frame sesaat.

Setiap frame, gelung memutuskan sama ada watak patut berlari: Sprint ditahan, watak sedang berjalan (Humanoid.MoveDirection sama dengan vektor sifar apabila ia berdiri) dan masih ada stamina. Untuk mula berlari, perlu sekurang-kurangnya MIN_TO_START (20); untuk terus berlari, apa-apa lebih daripada 0 sudah cukup. Tanpa jurang ini, bar kosong yang terisi sedikit setiap frame akan menghidupkan dan mematikan larian setiap frame. Pemulihan bermula REGEN_DELAY (1 saat) selepas larian atau dash terakhir, jadi selepas mengosongkan bar, pemain menunggu kira-kira 2.3 saat sebelum boleh berlari semula.

WalkSpeed hanya berubah pada frame larian bermula atau tamat. Pada permulaan, skrip mengingati WalkSpeed semasa dan menambah SPRINT_BONUS; pada penghujung, ia mengembalikan nilai yang diingati. Sebab itu kelajuan yang ditetapkan oleh skrip lain kekal: perk Speed daripada panduan game pass menetapkan WalkSpeed 24, dan dengan skrip ini pemiliknya berlari pada 34. Skrip yang menulis WalkSpeed = 16 setiap frame atau setiap kali dilepaskan akan membatalkan perk itu tanpa disedari.

Dash

Dash menolak watak ke arah ia bergerak, atau ke arah ia menghadap jika berdiri diam, dan arahnya diratakan supaya tidak pernah menghala ke atas atau ke bawah. Ia berharga 25 stamina, menjeda pemulihan seperti larian, dan ada cooldown 1 saat. Ia tidak menyemak tanah, jadi ia juga berfungsi di udara, yang sesuai digabungkan dengan lompat berganda. Selagi watak duduk, dash tidak berbuat apa-apa: watak yang duduk dikimpal pada tempat duduk, dan dalam kenderaan tolakan itu boleh menggerakkan seluruh kenderaan.

Tolakan itu ialah constraint LinearVelocity pada RootAttachment part akar. Dalam mod Plane dengan paksi X dan Z, ia mengekalkan kelajuan mendatar 60 stud sesaat dan tidak menyentuh paksi menegak, jadi graviti berfungsi dan dash dari tebing jatuh seperti biasa. MaxForce ialah math.huge, jadi tolakan tidak dihadkan oleh apa-apa. Debris:AddItem memusnahkan constraint selepas DASH_SECONDS tanpa membuat skrip menunggu, jadi dash berlangsung 0.2 saat, kira-kira 12 stud pada kelajuan ini.

Tutorial lama menggunakan BodyVelocity, yang telah ditanda Roblox sebagai lapuk dengan nota supaya menggunakan LinearVelocity. Helahnya dengan MaxForce sifar pada satu paksi digantikan oleh mod Line, Plane dan Vector pada LinearVelocity. Kerana peranti pemain sendiri mensimulasikan wataknya, constraint yang dicipta oleh LocalScript menggerakkannya, dan pemain lain melihat dash itu seperti pergerakan lain.

Tutorial UI Roblox sendiri melekatkan constraint pada humanoid.RootPart.RootAttachment dengan cara yang sama. Jika game anda menggunakan watak sendiri yang part akarnya tiada Attachment bernama RootAttachment, dash tidak berbuat apa-apa: tambahkannya pada HumanoidRootPart StarterCharacter anda.

Langkah 4: lompat berganda

Lompat berganda berada dalam LocalScriptnya sendiri dalam StarterCharacterScripts. Roblox meletakkan salinan skrip daripada bekas ini dalam setiap watak semasa spawn, dan salinan itu tidak kekal selepas respawn, jadi setiap nyawa bermula dengan skrip baharu dan tiada apa yang dibawa dari nyawa sebelumnya.

  1. Dalam Explorer, kembangkan StarterPlayer, halakan tetikus pada StarterCharacterScripts dan masukkan LocalScript bernama DoubleJump.
  2. Gantikan kandungannya dengan kod di bawah.
LocalScript dalam StarterCharacterScripts bernama DoubleJump
-- Memberi satu lompatan tambahan di udara. Dijalankan semula untuk setiap watak baharu,
-- jadi selepas respawn tiada apa yang dibawa.

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 tercetus beberapa kali untuk satu tekanan
local NEW_PRESS_GAP = 0.1 -- butang lompat yang ditahan terus menghantar JumpRequest; jeda sepanjang ini bermakna ia telah dilepaskan

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
		-- Lompatan dari tanah (bukan salah satu lompatan udara kita) memulihkan lompatan udara
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest tercetus apabila pemain meminta lompatan, contohnya melalui Space atau butang lompat pada telefon
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Hanya tekanan baharu yang melompat semula, supaya butang yang ditahan tidak menghabiskan lompatan udara
	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)

Tetapkan EXTRA_JUMPS kepada 2 untuk lompat tiga kali.

Skrip memerhati keadaan watak melalui Humanoid.StateChanged. Peralihan ke Jumping yang tidak datang dari Freefall ialah lompatan dari tanah, jadi ia memberi satu lompatan udara, dan Landed mengambilnya semula. Jika anda melangkah keluar dari tebing, watak masuk ke Freefall tanpa melompat, jadi ia tidak mendapat lompatan udara. Jika anda mahukannya di situ juga, tetapkan jumpsLeft juga semasa peralihan ke Freefall daripada mana-mana keadaan selain Jumping.

UserInputService.JumpRequest tercetus apabila pemain meminta lompatan, contohnya melalui Space atau butang lompat pada telefon. Rujukan Roblox memberi amaran bahawa ia tercetus beberapa kali untuk satu permintaan lompat dan mengesyorkan debounce, jadi skrip mengabaikan permintaan dalam tempoh 0.25 saat selepas lompatan terakhir. Butang lompat yang ditahan juga boleh terus meminta lompatan dan akan menghabiskan lompatan udara sebaik sahaja watak meninggalkan tanah, jadi permintaan hanya dikira sebagai tekanan baharu selepas 0.1 saat tanpa permintaan.

Lompatan udara itu sendiri ialah Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Rujukan Roblox menyatakan ia perlu dipanggil daripada LocalScript pada peranti yang memiliki pemilikan rangkaian ke atas watak, dan secara lalai itu ialah peranti pemain sendiri, bukan pelayan. Contoh kod untuk ChangeState dalam rujukan itu memang lompat berganda.

Langkah 5: tangkap speed hack pada pelayan

Tutorial larian sering berhenti pada client. Script pelayan tidak boleh mempercayai WalkSpeed pemain, kerana pengeksploit mengubahnya pada peranti mereka, tetapi ia nampak di mana watak mereka berada. MovementCheck mengukur ini dua kali sesaat dan menulis amaran dalam Output apabila seseorang bergerak lebih laju daripada yang dibenarkan oleh larian dan dash untuk tempoh yang lama. Ia membaca nombor larian dan dash daripada MovementConfig, jadi tambah modul itu daripada Langkah 2 walaupun anda mengekalkan ShiftToSprint.

  1. Halakan tetikus pada ServerScriptService dan masukkan Script bernama MovementCheck.
  2. Gantikan kandungannya dengan kod di bawah.
Script dalam ServerScriptService bernama MovementCheck
-- Peranti pemain menggerakkan watak mereka, jadi pengeksploit boleh menetapkan apa-apa WalkSpeed.
-- Semakan ini mengukur sejauh mana setiap watak sebenarnya bergerak, dan menulis dalam Output
-- apabila seseorang bergerak lebih laju daripada yang dibenarkan larian dan dash untuk tempoh lama. Ia hanya memberi amaran:
-- lag, teleport dan conveyor boleh kelihatan seperti melebihi kelajuan, jadi laraskannya sebelum menghukum sesiapa.

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 -- saat
-- Kelajuan larian serta ruang untuk lag. Naikkan jika anda menjual kelajuan tambahan.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- ruang untuk satu atau dua dash
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- berapa cepat dash lepas dimaafkan

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- part akar tempat lastPosition diukur
local excess: { [Player]: number } = {} -- stud melebihi had, dimaafkan secara beransur-ansur

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 ialah part akar baharu, dan teleport pelayan (mula pusingan, checkpoint)
			-- menetapkan atribut di bawah: mula mengukur semula, jangan tandakan lompatan
			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
				-- Hanya pergerakan mendatar: jatuh dengan laju bukan menipu
				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

Amaran muncul dalam Output dalam Studio. Dalam game sebenar, ia masuk ke log pelayan Developer Console, yang boleh anda baca sebagai pemilik game: lihat output dalam game sebenar.

Apa yang diukurnya

Setiap setengah saat, skrip membaca kedudukan part akar setiap watak dan mengukur sejauh mana ia telah bergerak secara mendatar sejak semakan sebelumnya. Ketinggian diabaikan, jadi jatuh dan lompatan tidak pernah dikira; nasihat Roblox tentang semakan pergerakan mencadangkan unjuran yang sama pada satah XZ untuk game di mana pemain berjalan di atas tanah. Hadnya ialah kelajuan berjalan lalai serta bonus larian dan suku lagi untuk lag: 32.5 stud sesaat. Jarak melebihi itu masuk ke dalam "baldi bocor", pengumpul yang menurut dokumentasi Roblox sesuai bagi banyak pembangun untuk lonjakan pendek. Baldi kehilangan 3 stud setiap semakan, dan skrip memberi amaran apabila ia mengandungi lebih daripada 24 stud, iaitu ruang untuk kira-kira dua dash.

Apa yang ditangkap oleh semakan, jika dikira mengikut nombornya
PenipuApa yang dibuat MovementCheck
Menetapkan WalkSpeed 100Memberi amaran selepas kira-kira satu saat berlari
Menetapkan WalkSpeed 50Memberi amaran selepas kira-kira 2.5 saat berlari
Membuat dash berturut-turut tanpa cooldown (60 stud sesaat)Memberi amaran selepas kira-kira 1.5 saat
Teleport lebih daripada 43 stud sekali gusMemberi amaran pada semakan seterusnya
Berlari pada kelajuan sehingga 38 stud sesaat, kira-kira satu setengah kali lebih laju daripada larianTiada apa-apa: di bawah 38.5 stud sesaat, baldi kosong secepat ia terisi
Mengubah MovementConfig sendiri untuk stamina tanpa hadTiada apa-apa: berlari pada 26 stud sesaat dibenarkan selama mana pun
Terbang, melompat tanpa had atau menembusi dindingTiada apa-apa: semakan mengabaikan ketinggian dan tidak melihat perlanggaran

Jadi, semakan ini menangkap penipuan kasar di mana pemain jelas lebih laju daripada orang lain, dan terlepas penipuan yang berhati-hati. Ini had jujur semakan berdasarkan jarak dan sebab Roblox membina sesuatu yang lebih kuat (lihat server authority di bawah).

Kenapa ia hanya memberi amaran

Dokumentasi Roblox mencatat bahawa semakan kelajuan ringkas boleh menandakan pemain jujur yang sambungannya tidak stabil dan rosak dalam game dengan kenderaan atau pergerakan kompleks lain. Lonjakan lag, conveyor, kenderaan, letupan yang melontar watak dan teleport anda sendiri boleh kelihatan seperti melebihi kelajuan, jadi skrip hanya mencetak amaran. Perhatikan Output semasa anda dan penguji anda bermain seperti biasa, naikkan SPEED_ALLOWANCE jika pemain jujur tersangkut padanya, dan tambah hukuman, contohnya menghantar pemain kembali, hanya apabila semakan diam semasa permainan biasa. Jika game anda ada letupan yang melontar watak, langkau juga pemain yang Humanoidnya sudah tiada nyawa.

Respawn dan teleport

Respawn mencipta part akar baharu, dan skrip mula mengukur semula apabila ia melihatnya, jadi mati jauh dari titik spawn tidak pernah dikira sebagai melebihi kelajuan. Teleport yang dibuat oleh skrip pelayan anda sendiri memerlukan pengecualian, seperti yang dinyatakan dalam dokumentasi Roblox untuk mana-mana game dengan teleport. Selepas teleport, tambah player:SetAttribute("MovementCheckSkip", true), dan semakan seterusnya akan mula mengukur dari kedudukan baharu dan tidak menandakan lompatan:

  • Dalam sistem pusingan, sejurus selepas character:PivotTo(...) dalam startRound.
  • Dalam skrip checkpoint obby, sejurus selepas setiap character:PivotTo(...) yang memindahkan pemain ke checkpointnya.

Pad dan menu daripada panduan teleport dan pad Finish daripada panduan game pertama sudah menetapkannya selepas setiap perpindahan.

Hanya nilai daripada pelayan yang dikira. Atribut yang ditetapkan pemain pada perantinya kekal pada peranti itu (lihat apa yang direplikasi dan apa yang tidak), jadi penipu tidak boleh mematikan semakan dengannya.

Penyelesaian masa depan: server authority

Dokumentasi keselamatan Roblox menyebut model server authority, yang masih beta semasa penulisan, sebagai cara paling boleh dipercayai untuk menghentikan eksploit pergerakan. Pelayan menjadi sumber kebenaran, dan peranti pemain hanya melaporkan input mereka, yang menurut dokumentasi menghalang speed hack daripada berfungsi kerana peranti tidak pernah dipercayai untuk melaporkan kedudukannya sendiri.

Peralihan ini ialah penulisan semula, bukan pelarasan. Dalam model ini, pelayan yang mengira pergerakan, jadi WalkSpeed atau LinearVelocity yang hanya ditetapkan oleh LocalScript dibatalkan apabila keadaan daripada pelayan tiba. Dokumentasi Roblox menyatakan logik utama perlu berjalan dalam fungsi RunService:BindToSimulation() dalam ModuleScript yang dijalankan oleh kedua-dua client dan pelayan. Model ini juga memerlukan beberapa tetapan Workspace, termasuk PlayerScriptsUseInputActionSystem, jadi kawalan anda juga akan berpindah ke Input Action System. Kekalkan versi daripada panduan ini sehingga anda memindahkan larian, stamina dan dash ke dalam skema itu. Sehingga itu, semakan jarak seperti ini ialah apa yang diterangkan oleh bahagian Roblox tentang semakan pergerakan.

Langkah 6: uji pada setiap peranti

  1. Tekan Play dan tahan Shift sambil berjalan. Kelajuan naik dari 16 ke 26 stud sesaat, dan bar hijau di bahagian bawah skrin berkurang. Selepas kira-kira 5 saat ia kosong, dan anda kembali berjalan.
  2. Lepaskan Shift. Selepas 1 saat bar mula terisi. Sehingga ia terisi satu perlima, Shift tidak berbuat apa-apa.
  3. Tekan Q sambil berjalan: anda meluncur sedikit ke hadapan, dan suku bar hilang. Tekan Q sekali lagi serta-merta, dan tiada apa yang berlaku sehingga sesaat berlalu. Jika dash terasa terlalu pendek atau panjang, ubah DASH_SPEED atau DASH_SECONDS dalam MovementConfig.
  4. Lompat, kemudian tekan lompat sekali lagi di udara untuk lompatan kedua. Mendarat dan cuba lagi: setiap lompatan dari tanah memulihkan lompatan udara.
  5. Tahan Space sepanjang lompatan. Hasilnya patut satu lompatan, bukan dua, kerana lompatan udara memerlukan tekanan baharu.
  6. Hidupkan Device Simulator dalam Studio (semasa penulisan ia beta: File, Beta Features, New Device Simulator, kemudian mulakan semula Studio) atau hidupkan Device Emulator lama dalam menu Test. Pilih telefon dan tekan Play. Butang Sprint dan Dash akan muncul. Tahan Sprint sambil mengemudi, kemudian tahan butang lompat sepanjang lompatan dan semak bahawa hanya ada satu lompatan.
  7. Buka Controller Emulator (Controller pada tab Emulation atau Virtual controller pada panel Device Simulator). Tahan L3 sambil bergerak untuk berlari, tekan B untuk dash dan A dua kali untuk lompat berganda.
  8. Tetapkan semula watak melalui menu game. Bar penuh semula, tiada amaran MovementCheck dalam Output, dan jika anda masih mensimulasikan telefon, butang Sprint dan Dash masih ada.
  9. Sekarang bermain sebagai penipu. Tekan suis Client/Server sehingga Explorer memaparkan client, pilih Humanoid watak anda dalam Workspace dan tetapkan WalkSpeed kepada 60 dalam tetingkap Properties. Berjalan selama beberapa saat: amaran seperti MovementCheck: YourName moved 60 studs/s akan muncul dalam Output. Kembalikan kepada 16, kemudian berlari dan dash seperti biasa selama seminit dan semak bahawa Output diam.
  10. Jika Workspace.PlayerScriptsUseInputActionSystem dalam place anda ditetapkan kepada Enabled, uji lompat berganda sekali lagi: dokumentasi Roblox tidak menyatakan sama ada JumpRequest berkelakuan sama dengannya.

Jika langsung tiada apa yang berlaku, buka tetingkap Output melalui menu Window dalam Studio dan cari ralat merah daripada MovementClient, atau lihat ralat biasa.

Berapa laju dan berapa lama: pratetap mengikut jenis game

Larian yang betul bergantung pada game. Kejaran dalam game seram memerlukan larian pendek dan perlahan yang habis pada saat paling buruk; peta terbuka yang besar memerlukan larian panjang supaya pemain tidak bosan merentasinya. Pratetap ini menggunakan skrip yang sama dan hanya mengubah kelajuan berjalan dan MovementConfig. Ini titik permulaan kami, dikira berdasarkan tetapan, bukan diukur pada pemain.

Kelajuan berjalan, larian dan stamina mengikut jenis game. Masa larian ialah MAX_STAMINA / DRAIN_PER_SECOND; pemulihan ialah MAX_STAMINA / REGEN_PER_SECOND serta 1 saat REGEN_DELAY
Jenis gameCharacterWalkSpeedSPRINT_BONUS (kelajuan larian)DRAIN_PER_SECONDREGEN_PER_SECONDLarian penuhDari kosong ke penuhJarak pada satu bar
Panduan ini1610 (26)20155 s7.7 s130 stud
Kejaran game seram128 (20)25104 s11 s80 stud
Battlegrounds dan pertarungan1612 (28)15206.7 s6 skira-kira 187 stud
Dunia terbuka atau simulator1616 (32)102510 s5 s320 stud
Obby atau parkour168 (24)tanpa stamina: gunakan ShiftToSprint
  • Kelajuan berjalan ditetapkan dalam StarterPlayer. Pilih StarterPlayer dan tetapkan CharacterWalkSpeed (lalai 16). Setiap watak baharu bermula dengan kelajuan ini, larian menambah SPRINT_BONUS padanya, dan MovementCheck juga membacanya, jadi semakan pelayan mengikut pilihan anda.
  • MovementCheck menyesuaikan diri. Ia membenarkan kelajuan berjalan serta bonus larian dan suku lagi untuk lag: 25 stud sesaat untuk pratetap game seram, 40 untuk dunia terbuka. Tiada apa lagi yang perlu diubah.
  • Dalam obby, larian mengubah laluan. Dengan larian yang lebih laju, jurang yang lebih panjang boleh dilompati. Bina lompatan, kemudian uji setiap satu pada kelajuan larian, jika tidak larian akan menjadikan peringkat terlalu mudah. Panduan checkpoint obby sesuai digabungkan dengan ShiftToSprint.
  • Dalam game seram, penanda arasnya ialah pembunuh. Jadikan pengejar sedikit lebih laju daripada kelajuan berjalan dan sedikit lebih perlahan daripada larian, supaya melarikan diri bergantung pada bila bar habis. Panduan game seram menerangkan selebihnya kitaran.

Apa yang salah dengan skrip larian lama

Tutorial lama untuk larian, dash dan lompat berganda selalunya masih berfungsi, tetapi banyak yang menggunakan teknik yang sejak itu telah digantikan oleh Roblox, atau merosakkan sistem lain dalam game anda. Jika anda membaiki skrip yang disalin, bandingkan dengan senarai ini.

Teknik daripada tutorial lama dan apa yang dibuat oleh panduan ini sebagai gantinya
TeknikApa masalahnyaPanduan ini
BodyVelocity untuk dashLapuk: Roblox menyatakan supaya menggunakan LinearVelocity sebagai gantinyaLinearVelocity dalam mod Plane
Gelung pada RunService.RenderSteppedUntuk kerja baharu ia telah digantikan oleh PreRender. Logik permainan seperti stamina sepatutnya berada pada Heartbeat, yang Roblox terangkan untuk tugas berkala seperti pemulihan nyawaHeartbeat dengan deltaTime
Kitaran stamina pada wait()wait() telah lapuk dan digantikan oleh task.wait() serta diperlahankan, jadi ia boleh menunggu lebih lama daripada yang diminta, dan penggunaan tetap bagi setiap wait menghabiskan stamina secara tidak sekataPenggunaan dan pemulihan setiap frame dengan mengambil kira deltaTime
UserInputService.InputBegan tanpa semakan chatMenekan Shift semasa menaip mesej dalam chat memulakan larianContextActionService, yang juga menambah butang pada telefon
WalkSpeed = 16 apabila dilepaskan atau setiap frameMenulis ganti apa-apa kelajuan lain, contohnya perk game passMengubah WalkSpeed hanya pada permulaan dan penghujung larian, dengan menambah pada nilai semasa
Larian melalui RemoteEvent supaya pelayan yang menetapkan WalkSpeedPengeksploit tetap menetapkan WalkSpeed sendiri, dan larian bermula dengan lengah perjalanan pergi balikLarian pada client serta semakan jarak pada pelayan
Lompat berganda pada setiap JumpRequestJumpRequest tercetus beberapa kali untuk satu permintaan lompat, dan butang yang ditahan boleh terus meminta lompatanJeda 0.25 saat dan semakan tekanan baharu
UserInputService.TouchEnabled sebagai semakan "ini telefon"Ia bernilai true pada komputer riba dengan skrin sentuhContextActionService menambah butang pada skrin peranti sentuh tanpa semakan peranti anda sendiri
Humanoid:LoadAnimation untuk animasi larianLapuk dan digantikan oleh Animator:LoadAnimationAnimasi larian di bawah menggunakan Animator

Cara baharu daripada Roblox: Input Action System

Halaman Roblox tentang Input Action System menggunakan larian watak sebagai contoh pertamanya. Sebagai ganti panggilan BindAction, kawalan disediakan dalam Studio: InputAction bernama CharacterSprint di dalam input context dalam ReplicatedStorage, dengan satu InputBinding untuk Left Shift, satu untuk butang Y pada gamepad dan satu yang dikaitkan dengan butang pada skrin yang anda lukis dalam StarterGui. Kemudian skrip client mendengar event tindakan Pressed dan Released, menggandakan WalkSpeed apabila ditekan dan mengembalikannya apabila dilepaskan.

Berbaloi beralih kepadanya jika anda mahu menyusun kawalan dalam Studio dan bukan dalam kod, butang sentuh anda sendiri sebagai ganti butang ContextActionService, atau context yang menukar seluruh set kawalan, contohnya untuk menu atau kenderaan. Halaman itu juga mengesyorkan menetapkan Workspace.PlayerScriptsUseInputActionSystem kepada Enabled, dan server authority memerlukannya.

Kitaran stamina dan dash daripada panduan ini berfungsi dengan cara yang sama dengan Input Action System sahaja (tanpa server authority). Kekalkan MovementConfig, gelung Heartbeat dan dash(), buang dua panggilan BindAction dan pengendalinya, dan sambungkan tindakan sebagai gantinya: Pressed tindakan larian menetapkan sprintHeld kepada true, dan Released nya kepada false, dan Pressed tindakan dash memanggil dash(). Teruskan mencari Humanoid setiap frame seperti yang dibuat oleh MovementClient, kerana contoh dalam dokumentasi menyimpan Humanoid watak pertama, dan selepas respawn ia sudah tiada.

Roblox juga sedang menguji Character Controller Library, beta yang dihidupkan dalam Beta Features dan Avatar Settings dalam Studio. Halamannya tentang kebolehan membina dash sebagai contoh dengan tetingkap aktif 0.2 saat dan cooldown 1 saat, iaitu masa yang sama seperti dash daripada panduan ini.

Cara mengembangkan: animasi, kamera dan pass larian

Animasi larian

Buat animasi larian dalam Animation Editor, beri ia keutamaan Movement (Roblox mengesyorkannya untuk animasi berjalan dan berlari), terbitkan dan salin ID asetnya. Dalam MovementClient, cipta Animation dengan AnimationId itu, muatkannya melalui Animator:LoadAnimation menggunakan Animator di dalam Humanoid watak, mainkan trek di tempat larian bermula dan hentikannya di tempat larian tamat. Muatkannya semula untuk setiap watak baharu.

Animasi yang dimainkan oleh peranti anda pada watak anda dilihat oleh semua orang jika anda menggunakan Animator yang diletakkan oleh Roblox di situ: trek yang dimuatkan pada Animator yang dicipta oleh LocalScript tidak direplikasi. Humanoid:LoadAnimation, yang digunakan oleh banyak tutorial lama, telah lapuk.

Kamera lebih luas semasa berlari

Sudut pandangan yang sedikit lebih luas menjadikan larian terasa lebih laju. Di dua tempat yang sama, tween workspace.CurrentCamera.FieldOfView daripada nilai lalai 70 kepada kira-kira 80 apabila larian bermula, dan kembali apabila ia tamat, contohnya melalui TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox mengehadkan nilai antara 1 dan 120 dan memberi amaran bahawa nilai yang sangat rendah atau sangat tinggi boleh mengelirukan pemain. Jika ada skrip lain dalam game yang mengubah sudut pandangan, tween kembali kepada nilai yang ditemui, bukan kepada 70.

Larian laju sebagai game pass

Panduan game pass sudah berfungsi dengan skrip ini: perk Speed nya pada pelayan menetapkan WalkSpeed 24 untuk setiap watak baharu, MovementClient menambah bonus larian di atasnya, dan 34 stud sesaat kekal dalam had yang dibenarkan oleh MovementCheck.

Untuk pass yang mempercepatkan larian itu sendiri, tambah pass FastSprint dalam PassConfig.ids daripada panduan itu. Skrip pelayannya kemudian menetapkan atribut OwnsPass_FastSprint pada pemain sebaik sahaja pembelian disahkan. Dalam MovementClient, gunakan bonus yang lebih besar daripada Config.SPRINT_BONUS apabila player:GetAttribute("OwnsPass_FastSprint") == true. Dalam MovementCheck, beri pemain sedemikian had yang lebih besar dengan membaca atribut yang sama pada pelayan, di mana pemain tidak boleh mengubahnya, dan semak bahawa kelajuan maksimum baharu kekal di bawah apa yang ditandakan oleh semakan.

Satu had yang perlu diketahui: jika skrip lain mengubah WalkSpeed di tengah larian, penghujung larian itu akan mengembalikan kelajuan yang ada sebelum ia bermula. Respawn seterusnya akan menetapkan kelajuan pass semula, kerana skrip game pass mengenakannya pada setiap watak baharu.

Ralat biasa dan cara membaikinya

Buka tetingkap Output (menu Window, kemudian Output) sebelum menekan Play. Kebanyakan masalah dengan skrip ini mencetak ralat atau amaran di situ dengan nama skrip dan nombor baris.

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

MovementClient atau MovementCheck menunggu modul yang tiada dengan nama tepat itu. Ia mesti ModuleScript bernama MovementConfig terus di dalam ReplicatedStorage. Panduan ralat skrip menerangkan amaran ini dengan terperinci.

Shift tidak berbuat apa-apa

Pastikan ShiftToSprint atau MovementClient ialah LocalScript, bukan Script, dan ia berada dalam StarterPlayerScripts. Dengan MovementClient, untuk mula berlari watak juga perlu sedang berjalan dan ada sekurang-kurangnya 20 stamina, jadi tahan Shift sambil bergerak. Jika Shift Lock yang bertukar dan bukan larian, lihat soalan tentang Shift Lock di bawah.

Larian berhenti selepas beberapa saat

Itu stamina yang habis: 100 stamina pada 20 sesaat cukup untuk 5 saat. Naikkan MAX_STAMINA atau kurangkan DRAIN_PER_SECOND dalam MovementConfig.

Dash tidak berbuat apa-apa

Dash memerlukan 25 stamina, menunggu 1 saat selepas dash sebelumnya dan tidak berbuat apa-apa semasa anda duduk. Jika bukan itu puncanya, part akar watak anda mungkin tiada Attachment bernama RootAttachment, yang berlaku pada sesetengah watak tersuai: tambahkannya pada HumanoidRootPart StarterCharacter anda.

Lompat berganda tidak berfungsi

DoubleJump mesti LocalScript dalam StarterCharacterScripts, bukan dalam StarterPlayerScripts, kerana ia membaca script.Parent sebagai watak. Tekan lompat kali kedua selepas meninggalkan tanah: butang yang ditahan tidak dikira sebagai tekanan baharu, dan melangkah keluar dari tebing tidak memberi lompatan udara.

Tiada butang Sprint atau Dash pada telefon

ContextActionService hanya menambah butangnya pada peranti sentuh, jadi pada PC tanpa skrin sentuh ia tidak pernah kelihatan. Uji dengan telefon dalam Device Simulator dalam Studio (ia beta: hidupkan New Device Simulator dalam File, Beta Features dan mulakan semula Studio). BindAction boleh mencipta tidak lebih daripada 7 butang sentuh, jadi kira berapa banyak yang dibuat oleh skrip lain dalam game.

MovementCheck memberi amaran tentang pemain jujur

Punca biasa: teleport daripada skrip pelayan lain, conveyor atau kenderaan, atau lag. Tetapkan atribut MovementCheckSkip selepas teleport anda (lihat Respawn dan teleport) dan naikkan SPEED_ALLOWANCE jika semakan masih tercetus dalam permainan biasa.

Kelajuan tambahan hilang selepas berlari

Skrip lain mengubah WalkSpeed semasa larian, dan larian, apabila tamat, mengembalikan kelajuan yang dilihatnya pada permulaan. Berikan kelajuan tambahan semasa watak spawn, seperti yang dibuat oleh panduan game pass, supaya respawn menetapkan kelajuan yang betul semula.

Buat dengan RoCode

Jika anda tidak mahu menyediakan semua ini sendiri, RoCode boleh membinanya dalam place yang sedang anda buka. RoCode ialah ejen AI bebas untuk Roblox Studio, bukan daripada Roblox: anda terangkan perubahan dalam chat web, dan plugin Studionya mencipta skrip dalam Explorer anda, jadi anda tidak perlu menampal kod.

Anda tulis

Tambah larian dengan Shift dan bar stamina: kelajuan berjalan tambah 10 selagi Shift ditahan, 100 stamina, penggunaan 20 sesaat, pemulihan 15 sesaat selepas sesaat rehat, butang Sprint pada telefon, dash pada Q dan lompat berganda.

RoCode buat
  • Boleh meninjau place anda dahulu melalui Search Scripts dan Read Script untuk mencari skrip lain yang mengubah WalkSpeed (contohnya perk game pass), supaya larian ditambah padanya
  • Menulis ModuleScript, LocalScript dan semakan pelayan melalui Create Script
  • Diarahkan untuk menyemak kompilasi setiap skrip yang ditulis melalui Check Script, yang mengkompilnya dalam Studio tanpa menjalankannya
  • Meletakkan titik undo sebelum dan selepas setiap kumpulan perubahan, jadi Ctrl+Z membatalkan satu kumpulan pada satu masa

RoCode tidak boleh membuat animasi larian: ciptanya dalam Animation Editor dan tampal IDnya. Dengan plugin 3.9.11 atau lebih baharu, RoCode boleh menjalankan playtest game anda dalam Studio dan mengawal watak ujian untuk menyemak bahawa semuanya berfungsi, dan dengan plugin 3.9.15 atau lebih baharu watak ujian boleh menekan kekunci, contohnya menahan Shift dan menyemak bahawa WalkSpeed meningkat. Ia sendiri memutuskan bila menjalankan playtest, sehingga 2 bagi setiap binaan serta 1 untuk menyemak pembaikannya, dan hanya menyemak apa yang diputuskannya untuk diuji, jadi cuba larian, dash dan lompat berganda sendiri, dan semak butang telefon dalam Device Simulator dalam Studio. Pergerakan ialah satu sistem daripada banyak dalam game; membina seluruh game dengan RoCode berjalan satu sistem bagi setiap prompt, seperti di sini. Cara RoCode bersambung ke Studio.

Soalan lazim

Kenapa skrip lari tidak berfungsi pada telefon?

Telefon tiada kekunci Shift. Ikat larian melalui ContextActionService:BindAction dan hantar true sebagai argumen ketiga: ini menambah butang pada skrin peranti sentuh, seperti yang dibuat oleh ShiftToSprint dan MovementClient.

Perlukah larian dibuat pada pelayan?

Tidak. Setiap peranti menggerakkan wataknya sendiri, jadi WalkSpeed yang ditetapkan oleh pelayan tidak akan menghalang penipu yang boleh menetapkan WalkSpeed sendiri, dan kelajuan baharu hanya tiba selepas perjalanan pergi balik, jadi larian bermula dengan lengah. Buat larian pada client, dan pada pelayan semak sejauh mana watak sebenarnya bergerak, seperti dalam Langkah 5. Beta server authority daripada Roblox berfungsi dengan cara lain, dan kod pergerakan perlu ditulis semula untuknya.

Kenapa watak terus berlari apabila saya melepaskan Shift?

Skrip terlepas lepasan, biasanya kerana ia hanya mendengar tekanan. ContextActionService menghantar End apabila kekunci dilepaskan, dan Cancel apabila ia diambil alih oleh ikatan lain; MovementClient berhenti pada kedua-duanya, dan juga apabila stamina habis atau watak berhenti bergerak.

Bagaimana menambah animasi larian?

Muatkan animasi larian melalui Animator dalam Humanoid watak dalam LocalScript yang sama, mainkannya apabila larian bermula dan hentikannya apabila ia tamat. Beri ia keutamaan Movement. Animasi yang dimainkan pada watak anda sendiri dilihat oleh semua orang.

Kenapa lompat berganda pada telefon tercetus sendiri?

Butang lompat yang ditahan pada telefon terus meminta lompatan. Anggap lompatan sebagai baharu hanya jika permintaan berhenti seketika, seperti yang dibuat oleh skrip DoubleJump.

Apakah kelajuan berjalan lalai dalam Roblox?

16 stud sesaat. Ia diambil daripada StarterPlayer.CharacterWalkSpeed, yang menetapkan Humanoid.WalkSpeed setiap watak baharu. Larian daripada panduan ini menambah 10, jadi larian bergerak pada 26.

Berapa laju larian dalam Roblox sepatutnya?

Kebanyakan game menambah antara separuh hingga satu kali ganda kelajuan berjalan: 16 menjadi sesuatu antara 24 dan 32. Larian pendek dan perlahan sesuai untuk game seram, dan larian panjang dan laju untuk peta besar. Pratetap mengikut jenis game memberi kelajuan berjalan, bonus larian dan nombor stamina untuk setiap satu.

Bagaimana buat larian dengan stamina?

Simpan nombor stamina pada peranti pemain, kurangkannya setiap frame semasa berlari dan pulihkannya selepas rehat pendek, kedua-duanya dengan mengambil kira masa frame, dan hentikan larian apabila ia mencapai 0. MovementClient daripada Langkah 3 membuat ini dengan bar pada skrin; nombornya berada dalam MovementConfig.

Bagaimana berlari dengan alat kawalan dalam Roblox?

Ikat ButtonL3 gamepad (tekan analog kiri) melalui ContextActionService bersama Left Shift, seperti yang dibuat oleh kedua-dua skrip di sini. ShiftToSprint menjadikan L3 togol, kerana menahan analog ditekan sambil mengemudi dengannya memenatkan.

Adakah lari dengan Shift bercanggah dengan Shift Lock?

Boleh. Pemain yang menghidupkan Shift Lock dalam tetapan Roblox menogolnya dengan kekunci Shift, jadi satu kekunci membuat dua perkara. Dokumentasi Roblox menyatakan API Shift Lock sedang ditamatkan penggunaannya. Jika konflik ini mengganggu pemain anda, matikan StarterPlayer.EnableMouseLockOption atau ikat larian dalam MovementClient pada kekunci lain, contohnya Left Ctrl.

Sumber dan bacaan lanjut

Cara kod disemak: setiap skrip di halaman ini lulus semakan jenis Luau yang ketat dengan definisi API Roblox (luau-lsp, 20 November 2026). Semakan jenis mengesan kesilapan nama API dan jenis yang salah, tetapi bukan kesilapan logik permainan, jadi uji semuanya dalam Studio sebelum anda menerbitkannya.

Cuba RoCode dalam permainan anda.

Kredit percuma setiap hari, tanpa kad. Pasang plugin, terangkan ciri yang anda mahu dan semak hasilnya dalam Studio.