Ръководство · Игрови системи

Как да направиш бягане със Shift в Roblox Studio за PC, телефон и конзола

Бягането със Shift в Roblox се свежда до едно число: WalkSpeed на Humanoid, което расте, докато Shift е натиснат. Стъпка 1 прави точно това в един кратък LocalScript, който работи и с бутона Sprint на телефона, и с геймпад. Останалата част от ръководството добавя това, което трябва на голяма игра: лента за стамина, даш (рязък тласък напред) с модерната физика, двоен скок, който не се задейства от задържан бутон, и разбиране какво може да провери сървърът и какво не.

Обновено 20 ноември 2026 г.25 мин четенеАвтор:

Накратко

Сложи един LocalScript в StarterPlayerScripts, който свързва действието Sprint чрез ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Докато Shift е натиснат, добавяй 10 към Humanoid.WalkSpeed (16 става 26), а при пускане връщай предишната стойност. Аргументът true добавя бутон Sprint на сензорните екрани, а в скрипта от това ръководство този бутон и L3 на геймпада включват и изключват бягането, вместо да работят със задържане.

  • Добавяй към текущата WalkSpeed, а не задавай 26, за да се запази ускорението от геймпаса.
  • Бягането работи на устройството на играча. Сървърът не може да наложи WalkSpeed; той може само да измерва колко далеч се движат персонажите и да отбелязва скорост, която бягането не обяснява.
  • Лентата за стамина, дашът и двойният скок на същата идея се добавят в Стъпки 2 до 4. Колко бързо и колко дълго да се бяга, ще подскажат пресетите по тип игра с числа за хорър, бойни игри и отворен свят.
На тази страница
  1. Как работи
  2. 1. Бягане със Shift
  3. 2. Модул с настройки
  4. 3. Бягане и даш
  5. 4. Двоен скок
  6. 5. Проверка на сървъра
  7. 6. Тест
  8. Пресети за скорост
  9. Стари скриптове
  10. Input Action System
  11. Разширения
  12. Common errors
  13. С RoCode
  14. Често задавани въпроси
  15. Източници и какво да прочетеш

Как работи бягането в Roblox

ИлюстрацияShift дава бягане с WalkSpeed 26, докато лентата намалява, Q прави даш за една четвърт от лентата, а второто натискане на скока във въздуха скача още веднъж.

Устройството на всеки играч движи собствения му персонаж. Клавиатурата, контролерът или сензорният екран решават накъде отива персонажът, а Roblox предава резултата на сървъра и на всички останали. Затова бягането е LocalScript, който вдига Humanoid.WalkSpeed, докато клавишът е натиснат, и това е всичко, което прави Стъпка 1. Останалата част от ръководството е това, което трябва на голяма игра около него: лента за стамина, даш, двоен скок и проверка на сървъра срещу измамници.

От какво се състои системата за движение
ЕлементКъде се намираКакво прави
LocalScript ShiftToSprintStarterPlayerScriptsСтъпка 1 сама по себе си: бягане с клавиатура, телефон и геймпад, без стамина. Когато добавиш стамина и даш, го заменя MovementClient.
ModuleScript MovementConfigReplicatedStorageЧислата: бонус за бягане, стамина и даш. Чете ги и LocalScript, и проверката на сървъра.
LocalScript MovementClientStarterPlayerScriptsСвързва Sprint и Dash с клавиш, бутон на геймпада и сензорен бутон, върти цикъла на стамината, рисува лентата и прави даша.
LocalScript DoubleJumpStarterCharacterScriptsДава един допълнителен скок във въздуха. Ново копие се пуска във всеки нов персонаж.
Script MovementCheckServerScriptServiceИзмерва колко далеч всъщност се движи всеки персонаж и пише предупреждение в Output, когато някой дълго се движи по-бързо, отколкото позволяват бягането и дашът.
Explorer, когато системата за движение е готова
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Ако разликата между Script и LocalScript е нова за теб, Script, LocalScript и ModuleScript обяснява къде се пуска всеки вид и защо.

Стъпка 1: бягане със Shift в един LocalScript

Ако ти трябва само по-бързо бягане, докато Shift е натиснат, стига само този скрипт. Той дава и бутон Sprint на екрана на телефоните, а на геймпада позволява да бягаш с левия стик.

  1. В Explorer разгъни StarterPlayer, задръж мишката върху StarterPlayerScripts, натисни бутона + и вмъкни LocalScript с име ShiftToSprint.
  2. Замени съдържанието му с кода по-долу и натисни Play.
LocalScript в StarterPlayerScripts с име ShiftToSprint
-- LocalScript в StarterPlayer > StarterPlayerScripts с име ShiftToSprint.
-- Задръж Left Shift, за да бягаш. На геймпада натисни левия стик (L3), за да
-- включиш или изключиш бягането. На телефона натисни бутона Sprint, за да го включиш или изключиш.

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

-- Настройки
local SPRINT_BONUS = 10 -- добавя се към WalkSpeed по време на бягане (16 става 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: бутонът трябва да се задържа

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- WalkSpeed, към която да се върнем

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

local function setSprinting(on: boolean)
	local humanoid = getHumanoid()
	if not humanoid or on == sprinting then
		return
	end
	sprinting = on
	if on then
		-- Запомняме текущата скорост и добавяме към нея, за да се запази ускорението от друг скрипт
		normalSpeed = humanoid.WalkSpeed
		humanoid.WalkSpeed = normalSpeed + SPRINT_BONUS
	else
		humanoid.WalkSpeed = normalSpeed
	end
end

local function onSprint(_name: string, state: Enum.UserInputState, input: InputObject): Enum.ContextActionResult
	local isKeyboard = input.UserInputType == Enum.UserInputType.Keyboard
	if isKeyboard or not TOGGLE_ON_TOUCH_AND_GAMEPAD then
		-- Задържане: бягане, докато клавишът или бутонът е натиснат
		if state == Enum.UserInputState.Begin then
			setSprinting(true)
		elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
			setSprinting(false)
		end
	elseif state == Enum.UserInputState.Begin then
		-- Превключване: всяко натискане включва или изключва бягането
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Едно извикване свързва клавиша, бутона на геймпада и, на сензорните екрани, бутона на екрана
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- Новият персонаж започва с ходене: неговият Humanoid вече има обичайната WalkSpeed
player.CharacterAdded:Connect(function()
	sprinting = false
end)

Променяй SPRINT_BONUS, за да е бягането по-бързо или по-бавно. Задай TOGGLE_ON_TOUCH_AND_GAMEPAD на false, за да работят бутонът на телефона и L3 като Shift: бягане само докато е задържан.

BindAction свързва едно действие с Left Shift и с бутона L3 на геймпада, а третият му аргумент, true, добавя бутон на сензорните екрани; SetTitle пише на него "Sprint". Обработчикът получава и самото въвеждане, затова различава натискане на клавиатурата от геймпад или сензорен бутон. Когато бягането започне, скриптът запомня текущата WalkSpeed и добавя SPRINT_BONUS; когато свърши, връща запомнената стойност. Скорост, зададена от друг скрипт, например перкът Speed от ръководството за геймпасове, се запазва. Новият персонаж започва с обичайната WalkSpeed, затова обработчикът на CharacterAdded само нулира флага.

Задържане или превключване?

Как работи ShiftToSprint на всяко устройство, когато TOGGLE_ON_TOUCH_AND_GAMEPAD е true
Устройство и въвежданеРаботи катоЗащо
Клавиатура: Left ShiftЗадържанеЛесно е да държиш клавиша, докато се движиш, а пускането веднага спира бягането.
Геймпад: натискане на левия стик (L3)ПревключванеДа държиш стика натиснат и едновременно да управляваш с него е изморително.
Телефон или таблет: бутон Sprint на екранаПревключванеПалецът, който държи бутона, не може в същото време да натисне Jump.

За да провериш, натисни Play и дръж Shift, докато вървиш: скоростта расте от 16 до 26 стъда в секунда, а ако пуснеш, ще забавиш. За телефон избери телефон в Device Simulator в Studio, натисни Play и натисни Sprint веднъж, за да започнеш, и още веднъж, за да спреш. За геймпад отвори Controller Emulator по време на плейтеста и натисни L3. Пълният списък с проверки по устройства е в Стъпка 6.

Стъпки 2 и 3 заменят този скрипт с друг, с лента за стамина и даш. Стъпки 4 и 5 добавят двоен скок и проверка на сървъра и работят с всеки от двата скрипта.

Стъпка 2: числата за стамината и даша в един модул

За бягане, което свършва, Стъпки 2 и 3 сменят ShiftToSprint с по-голям LocalScript с лента за стамина и даш. Първо изтрий ShiftToSprint: и двата скрипта свързват действието Sprint.

Всички числа са в един ModuleScript, затова усещането от движението се настройва на едно място. MovementClient ги чете на устройството на всеки играч, а MovementCheck чете същия модул на сървъра, за да знае каква трябва да е скоростта на бягането и даша.

  1. В Explorer задръж мишката върху ReplicatedStorage, натисни бутона + и вмъкни ModuleScript.
  2. Преименувай го на MovementConfig и замени съдържанието с кода по-долу.
ModuleScript в ReplicatedStorage с име MovementConfig
-- Един набор от числа за LocalScript на движението и проверката на скоростта на сървъра.

local MovementConfig = {
	SPRINT_BONUS = 10, -- добавя се към текущата WalkSpeed: 16 (стойността по подразбиране в Roblox) става 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 секунди бягане с пълна лента
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- секунди след края на бягането, преди стамината да започне да се възстановява
	MIN_TO_START = 20, -- стамина, нужна за старт на бягането, за да не мига празната лента

	DASH_SPEED = 60, -- стъда в секунда по време на даша
	DASH_SECONDS = 0.2, -- така дашът минава около 12 стъда
	DASH_COST = 25, -- стамина
	DASH_COOLDOWN = 1,
}

return MovementConfig
Какво прави всяка настройка
НастройкаСтойностЕфект
SPRINT_BONUS10Добавя се към WalkSpeed по време на бягане. WalkSpeed в Roblox по подразбиране е 16, затова бягането е със скорост 26 стъда в секунда.
MAX_STAMINA100Пълна лента.
DRAIN_PER_SECOND20Пълната лента стига за 5 секунди бягане.
REGEN_PER_SECOND15Празната лента се пълни за около 6.7 секунди.
REGEN_DELAY1Секунди почивка преди началото на възстановяването.
MIN_TO_START20Стамина, нужна, за да започнеш да бягаш.
DASH_SPEED60Стъда в секунда по време на даша.
DASH_SECONDS0.2Колко трае дашът: около 12 стъда при 60 стъда в секунда.
DASH_COST25Стамина за всеки даш.
DASH_COOLDOWN1Секунди между дашовете.

Всяка страна пуска свое копие на модула (модулът се изпълнява веднъж на всяка страна), затова играч, който променя тези числа на своето устройство, променя само своето копие. Но тук това нищо не защитава: неговото устройство и без това движи персонажа му, затова може да си даде безкрайна стамина, каквото и да има в модула. Проверката на сървъра от Стъпка 5 е изградена с това предвид.

Стъпка 3: бягане със стамина и даш

Този LocalScript прави това, което усещат играчите. Той свързва Sprint и Dash, рисува лентата за стамина, всеки кадър върти цикъла на стамината и прави даша.

  1. В Explorer разгъни StarterPlayer, задръж мишката върху StarterPlayerScripts и вмъкни LocalScript с име MovementClient.
  2. Замени съдържанието му с кода по-долу.
LocalScript в StarterPlayerScripts с име MovementClient
-- Задръж Shift (или L3, или бутона Sprint на телефона), за да бягаш, докато има стамина.
-- Натисни Q (или B, или бутона Dash), за да направиш даш в посоката на движение.

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

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

local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- WalkSpeed, към която да се върнем, когато бягането свърши
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Лента за стамина: рамка с пълнеж, чиято ширина е равна на оставащата стамина
local gui = Instance.new("ScreenGui")
gui.Name = "StaminaGui"
gui.ResetOnSpawn = false
local bar = Instance.new("Frame")
bar.AnchorPoint = Vector2.new(0.5, 1)
bar.Position = UDim2.new(0.5, 0, 1, -24)
bar.Size = UDim2.fromOffset(240, 14)
bar.BackgroundColor3 = Color3.fromRGB(30, 26, 40)
bar.Parent = gui
local fill = Instance.new("Frame")
fill.Size = UDim2.fromScale(1, 1)
fill.BackgroundColor3 = Color3.fromRGB(80, 220, 150)
fill.BorderSizePixel = 0
fill.Parent = bar
for _, frame in { bar, fill } do
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(1, 0)
	corner.Parent = frame
end
gui.Parent = player:WaitForChild("PlayerGui")

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

-- Бягане: тук е само флагът; цикълът Heartbeat по-долу всеки кадър решава дали да се бяга
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Променят го само натискането и пускането: пръст, който се плъзга по сензорния бутон, праща Change
	if state == Enum.UserInputState.Begin then
		sprintHeld = true
	elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
		sprintHeld = false
	end
	return Enum.ContextActionResult.Pass
end

local function dash()
	local humanoid = getHumanoid()
	local rootPart = humanoid and humanoid.RootPart
	local now = os.clock()
	-- Седнал няма даш: седналият персонаж е заварен към седалката, затова би бутнал цялото превозно средство
	if not (humanoid and rootPart) or humanoid.Sit or now - lastDashTime < Config.DASH_COOLDOWN or stamina < Config.DASH_COST then
		return
	end
	local attachment = rootPart:FindFirstChild("RootAttachment")
	if not (attachment and attachment:IsA("Attachment")) then
		return
	end
	lastDashTime = now
	stamina -= Config.DASH_COST
	lastSprintTime = now -- спираме възстановяването на пауза, както прави бягането

	-- Даш натам, накъдето се движи играчът, или натам, накъдето гледа, ако стои на място
	local direction = humanoid.MoveDirection
	if direction.Magnitude < 0.1 then
		direction = rootPart.CFrame.LookVector
	end
	direction = Vector3.new(direction.X, 0, direction.Z).Unit

	-- LinearVelocity в режим Plane държи хоризонталната скорост и не пречи на гравитацията
	local velocity = Instance.new("LinearVelocity")
	velocity.Attachment0 = attachment
	velocity.RelativeTo = Enum.ActuatorRelativeTo.World
	velocity.VelocityConstraintMode = Enum.VelocityConstraintMode.Plane
	velocity.PrimaryTangentAxis = Vector3.xAxis
	velocity.SecondaryTangentAxis = Vector3.zAxis
	velocity.PlaneVelocity = Vector2.new(direction.X, direction.Z) * Config.DASH_SPEED
	velocity.MaxForce = math.huge
	velocity.Parent = rootPart
	Debris:AddItem(velocity, Config.DASH_SECONDS)
end

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

-- Всяко извикване свързва клавиш, бутон на геймпада и, на сензорни устройства, бутон на екрана
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:BindAction("Dash", onDash, true, Enum.KeyCode.Q, Enum.KeyCode.ButtonB)
ContextActionService:SetTitle("Sprint", "Sprint")
ContextActionService:SetTitle("Dash", "Dash")

-- Всеки кадър: харчим стамина по време на бягане и движение, възстановяваме след кратка почивка
RunService.Heartbeat:Connect(function(deltaTime: number)
	local humanoid = getHumanoid()
	if not humanoid then
		return
	end
	local moving = humanoid.MoveDirection.Magnitude > 0
	local now = os.clock()
	local enoughStamina = if sprinting then stamina > 0 else stamina >= Config.MIN_TO_START
	local shouldSprint = sprintHeld and moving and enoughStamina

	-- Променяме WalkSpeed само в началото и в края на бягането, за да се запази скоростта,
	-- зададена от друг скрипт (например пас за скорост), а бягането да се добавя към нея
	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, затова остава на екрана след прераждане, а обработчикът на CharacterAdded най-долу я пълни наново за всеки нов персонаж. Редовете type Config описват какво връща модулът, за да хваща строгата проверка на типовете грешка в името на настройка; по време на игра те нищо не променят.

Клавиатура, геймпад и бутон на телефона с едно извикване

ContextActionService:BindAction приема името на действието, функцията обработчик, дали да се създаде сензорен бутон и след това въвежданията. Ако подадеш true като трети аргумент, ContextActionService ще добави бутон на екрана на сензорните устройства, вътре в ScreenGui с име ContextActionGui в PlayerGui на играча. SetTitle пише на тези бутони "Sprint" и "Dash". BindAction може да създаде не повече от 7 сензорни бутона, така че следи броя им, ако ги използват и други скриптове в играта.

Обработчикът получава състоянието на въвеждането: Begin при натискане и End при пускане. onSprint само запомня дали Sprint е задържан. Той смята за пускане и Cancel, който ContextActionService праща, когато въвеждането се прихване от друго свързване, и пренебрегва Change, който може да прати пръст, движещ се по сензорния бутон. И двата обработчика връщат Pass, затова следващото свързване на същия клавиш също получава въвеждането.

Справката на Roblox за ContextActionService го препоръчва вместо UserInputService.InputBegan в повечето случаи. Нейният пример: клаксон на кола с H, който не бива да свири, докато играчът пише в чата. Свързването се задейства само докато е последното за това въвеждане, затова, когато чатът вземе клавиатурата, не трябва нищо да проверяваш. Въвежданията на геймпада: ButtonL3 (натискане на левия стик, който се държи по време на движение) и ButtonB. В собствения пример за бягане на Roblox се използва ButtonY, така че смени KeyCode в BindAction, ако така е по-удобно за твоята игра.

Цикълът на стамината

RunService.Heartbeat се задейства всеки кадър след стъпката на физиката и подава deltaTime, броя секунди от предишния кадър. Ако умножаваш по него скоростта на харчене и възстановяване, пълната лента ще стига за 5 секунди, независимо дали играта върви на 30 или на 240 кадъра в секунда.

Всеки кадър цикълът решава дали персонажът трябва да бяга: Sprint е задържан, персонажът върви (Humanoid.MoveDirection е нулев вектор, когато стои) и още има стамина. За да започне бягането, трябва поне MIN_TO_START (20); за да продължи, стига всичко над 0. Без тази разлика празната лента, която всеки кадър се пълни съвсем малко, би включвала и изключвала бягането всеки кадър. Възстановяването започва REGEN_DELAY (1 секунда) след последното бягане или даш, затова, след като изпразни лентата, играчът чака около 2.3 секунди, преди отново да може да бяга.

WalkSpeed се променя само в кадъра, в който бягането започва или свършва. В началото скриптът запомня текущата WalkSpeed и добавя SPRINT_BONUS; в края връща запомнената стойност. Затова скоростта, зададена от друг скрипт, се запазва: перкът Speed от ръководството за геймпасове задава WalkSpeed 24 и с този скрипт притежателите му бягат с 34. Скрипт, който пише WalkSpeed = 16 всеки кадър или при всяко пускане, незабелязано би отменил този перк.

Даш

Дашът тласка персонажа натам, накъдето се движи, или натам, накъдето гледа, ако стои на място, като посоката се изравнява, за да не сочи никога нагоре или надолу. Той струва 25 стамина, спира възстановяването на пауза като бягането и има презареждане от 1 секунда. В него не се проверява земята, затова работи и във въздуха, което се съчетава добре с двойния скок. Докато персонажът седи, дашът не прави нищо: седналият персонаж е заварен към седалката и в превозно средство тласъкът би могъл да премести цялото превозно средство.

Тласъкът е ограничение LinearVelocity върху RootAttachment на основния парт. В режим Plane с осите X и Z то държи хоризонтална скорост от 60 стъда в секунда и не пипа вертикалата, затова гравитацията работи и даш от ръб пада както обикновено. MaxForce е math.huge, така че тласъкът не е ограничен от нищо. Debris:AddItem унищожава ограничението след DASH_SECONDS, без да кара скрипта да чака, затова дашът трае 0.2 секунди, около 12 стъда при тази скорост.

Старите туториали използват BodyVelocity, който Roblox е отбелязал като остарял с указание да се използва LinearVelocity вместо него. Трикът му с нулев MaxForce по една ос се заменя от режимите Line, Plane и Vector на LinearVelocity. Тъй като устройството на играча само симулира своя персонаж, ограничението, създадено от LocalScript, го движи и другите играчи виждат даша като всяко друго движение.

Собственият туториал на Roblox за UI закача ограничението към humanoid.RootPart.RootAttachment точно по същия начин. Ако в играта ти има собствен персонаж, чийто основен парт няма Attachment с име RootAttachment, дашът не прави нищо: добави го в HumanoidRootPart на твоя StarterCharacter.

Стъпка 4: двоен скок

Двойният скок живее в свой LocalScript в StarterCharacterScripts. Roblox слага копие на скриптовете от този контейнер във всеки персонаж при появата му и тези копия не оцеляват след прераждане, затова всеки живот започва с нов скрипт и нищо не се пренася от предишния.

  1. В Explorer разгъни StarterPlayer, задръж мишката върху StarterCharacterScripts и вмъкни LocalScript с име DoubleJump.
  2. Замени съдържанието му с кода по-долу.
LocalScript в StarterCharacterScripts с име DoubleJump
-- Дава един допълнителен скок във въздуха. Пуска се наново за всеки нов персонаж,
-- затова след прераждане нищо не се пренася.

local UserInputService = game:GetService("UserInputService")

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

local EXTRA_JUMPS = 1
local MIN_SECONDS_BETWEEN_JUMPS = 0.25 -- JumpRequest се задейства няколко пъти за едно натискане
local NEW_PRESS_GAP = 0.1 -- задържаният бутон за скок продължава да праща JumpRequest; пауза с такава дължина значи, че е пуснат

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

humanoid.StateChanged:Connect(function(oldState: Enum.HumanoidStateType, newState: Enum.HumanoidStateType)
	if newState == Enum.HumanoidStateType.Jumping and oldState ~= Enum.HumanoidStateType.Freefall then
		-- Скок от земята (не някой от нашите скокове във въздуха) възстановява скоковете във въздуха
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest се задейства, когато играчът поиска скок, например със Space или бутона за скок на телефона
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Скача отново само ново натискане, за да не харчи задържаният бутон скока във въздуха
	if not newPress or jumpsLeft <= 0 or now - lastJump < MIN_SECONDS_BETWEEN_JUMPS then
		return
	end
	if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
		jumpsLeft -= 1
		lastJump = now
		humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
	end
end)

Задай EXTRA_JUMPS на 2 за троен скок.

Скриптът следи състоянието на персонажа чрез Humanoid.StateChanged. Преминаване в Jumping, което не идва от Freefall, е скок от земята, затова дава скок във въздуха, а Landed отново го взема. Ако слезеш от ръб, персонажът влиза във Freefall без скок, затова не получава скок във въздуха. Ако ти трябва и там, задавай jumpsLeft и при преминаване във Freefall от всяко състояние освен Jumping.

UserInputService.JumpRequest се задейства, когато играчът поиска скок, например със Space или бутона за скок на телефона. Справката на Roblox предупреждава, че той се задейства няколко пъти за една заявка за скок, и съветва debounce, затова скриптът пренебрегва заявките 0.25 секунди след последния скок. Задържаният бутон за скок също може да продължи да иска скокове и би похарчил скока във въздуха в мига, в който персонажът се отлепи от земята, затова заявката се смята за ново натискане само след 0.1 секунди без заявки.

Самият скок във въздуха е Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Справката на Roblox казва, че трябва да се извиква от LocalScript на устройството, което има мрежовата собственост върху персонажа, а по подразбиране това е устройството на самия играч, а не сървърът. Примерният код към ChangeState в справката е точно двоен скок.

Стъпка 5: хващаме спийдхак на сървъра

Туториалите за бягане често спират при клиента. Сървърен Script не може да вярва на WalkSpeed на играча, защото експлойтърите я променят на своето устройство, но той вижда къде се озовава персонажът им. MovementCheck измерва това два пъти в секунда и пише предупреждение в Output, когато някой дълго се движи по-бързо, отколкото позволяват бягането и дашът. Числата за бягането и даша чете от MovementConfig, така че добави този модул от Стъпка 2, дори ако си оставил ShiftToSprint.

  1. Задръж мишката върху ServerScriptService и вмъкни Script с име MovementCheck.
  2. Замени съдържанието му с кода по-долу.
Script в ServerScriptService с име MovementCheck
-- Устройствата на играчите движат своите персонажи, затова експлойтър може да зададе каквато иска 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 } = {} -- основният парт, на който е измерена 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
			-- Прераждането е нов основен парт, а телепорт от сървъра (старт на рунд, чекпойнт)
			-- задава атрибута по-долу: започваме да мерим наново, вместо да отбележим скока
			local previous = if lastRoot[player] == rootPart then lastPosition[player] else nil
			if player:GetAttribute("MovementCheckSkip") then
				player:SetAttribute("MovementCheckSkip", nil)
				previous = nil
			end
			lastPosition[player] = position
			lastRoot[player] = rootPart
			if previous then
				-- Само хоризонтално движение: бързото падане не е измама
				local moved = Vector3.new(position.X - previous.X, 0, position.Z - previous.Z).Magnitude
				local extra = moved - SPEED_ALLOWANCE * CHECK_EVERY
				local total = math.max(0, (excess[player] or 0) + extra - DRAIN_PER_CHECK)
				excess[player] = total
				if total > BURST_ALLOWANCE then
					warn(`MovementCheck: {player.Name} moved {math.round(moved / CHECK_EVERY)} studs/s`)
					excess[player] = 0
				end
			end
		else
			lastPosition[player] = nil
			lastRoot[player] = nil
		end
	end
end

Предупреждението се появява в Output в Studio. В пусната игра то отива в сървърния лог на Developer Console, който можеш да четеш като собственик на играта: виж изхода в пусната игра.

Какво измерва

На всеки половин секунда скриптът чете позицията на основния парт на всеки персонаж и измерва колко се е преместил хоризонтално от предишната проверка. Височината се пренебрегва, затова паданията и скоковете никога не се броят; съветът на Roblox за проверка на движението предлага същата проекция върху равнината XZ за игри, в които се ходи по земята. Допускът е скоростта на ходене по подразбиране плюс бонуса за бягане и още една четвърт за лаг: 32.5 стъда в секунда. Разстоянието над това попада в „дупчеста кофа“, натрупвач, за който в документацията на Roblox пише, че подхожда добре на много разработчици за кратки изблици. Кофата губи 3 стъда при всяка проверка, а скриптът предупреждава, когато в нея има над 24 стъда, което е резерв за около два даша.

Какво хваща проверката, ако се сметне по нейните числа
ИзмамникКакво прави MovementCheck
Задава WalkSpeed 100Предупреждава след около секунда бягане
Задава WalkSpeed 50Предупреждава след около 2.5 секунди бягане
Прави дашове един след друг без презареждане (60 стъда в секунда)Предупреждава след около 1.5 секунди
Телепортира се на повече от 43 стъда наведнъжПредупреждава при следващата проверка
Бяга със скорост до 38 стъда в секунда, около един път и половина по-бързо от бяганетоНищо: под 38.5 стъда в секунда кофата се изпразва толкова бързо, колкото се пълни
Променя своя MovementConfig за безкрайна стаминаНищо: бягане с 26 стъда в секунда е позволено колкото дълго искаш
Лети, скача без ограничения или минава през стениНищо: проверката пренебрегва височината и не гледа сблъсъците

Значи проверката хваща грубите измами, при които играчът е видимо по-бърз от всички останали, и пропуска внимателните. Това е честната граница на проверка по разстояние и причината Roblox да прави нещо по-силно (виж server authority по-долу).

Защо само предупреждава

В документацията на Roblox е отбелязано, че простите проверки на скоростта могат да отбелязват честни играчи с нестабилна връзка и се чупят в игри с превозни средства или друго сложно движение. Скокове от лаг, конвейери, превозни средства, експлозии, които отхвърлят персонажи, и твоите собствени телепорти могат да изглеждат като превишена скорост, затова скриптът само печата предупреждение. Гледай в Output, докато ти и тестерите ти играете както обикновено, увеличи SPEED_ALLOWANCE, ако в него се спъват честни играчи, и добавяй наказание, например връщане на играча назад, само когато проверката мълчи при нормална игра. Ако в играта ти експлозиите отхвърлят персонажи, пропускай и играчите, чийто Humanoid няма останало здраве.

Прераждания и телепорти

Прераждането създава нов основен парт и скриптът започва да мери наново, когато го види, затова смърт далеч от точката на поява никога не се брои за превишена скорост. Телепортите, които правят твоите собствени сървърни скриптове, имат нужда от изключение, както пише в документацията на Roblox за всяка игра с телепорти. След телепорт добави player:SetAttribute("MovementCheckSkip", true) и следващата проверка ще започне да мери от новата позиция, вместо да отбележи скока:

Падовете и менютата от ръководството за телепорти и падът Finish от ръководството за първата игра вече го задават след всяко преместване.

Брои се само стойността от сървъра. Атрибут, който играчът задава на своето устройство, остава на това устройство (виж какво се репликира и какво не), затова измамник не може да изключи проверката с него.

Решение за в бъдеще: server authority

Документацията на Roblox за сигурност нарича модела server authority, към момента на писане в бета, най-надеждния начин да се спрат експлойтите в движението. Източник на истината става сървърът, а устройствата на играчите само съобщават своето въвеждане, което според документацията не позволява на спийдхаковете да работят, защото на устройството никога не се вярва да съобщава собствената си позиция.

Преминаването е пренаписване, а не настройка. В този модел движението се смята от сървъра, затова WalkSpeed или LinearVelocity, зададени само от LocalScript, се отменят, когато пристигне състоянието от сървъра. В документацията на Roblox пише, че основната логика трябва да работи във функции на RunService:BindToSimulation() в ModuleScript, който се пуска и от клиента, и от сървъра. Моделът изисква и няколко настройки на Workspace, включително PlayerScriptsUseInputActionSystem, така че управлението ти също ще се премести на Input Action System. Остави версията от това ръководство, докато не пренесеш бягането, стамината и даша в тази схема. Дотогава проверка по разстояние като тази е точно това, което описва разделът на Roblox за проверка на движението.

Стъпка 6: тествай на всяко устройство

  1. Натисни Play и дръж Shift, докато вървиш. Скоростта расте от 16 до 26 стъда в секунда, а зелената лента в долната част на екрана намалява. След около 5 секунди тя е празна и пак вървиш с нормален ход.
  2. Пусни Shift. След 1 секунда лентата започва да се пълни. Докато не се напълни до една пета, Shift не прави нищо.
  3. Натисни Q, докато вървиш: стрелваш се малко напред и една четвърт от лентата изчезва. Натисни Q веднага още веднъж и нищо няма да стане, докато не мине секунда. Ако дашът изглежда твърде къс или дълъг, промени DASH_SPEED или DASH_SECONDS в MovementConfig.
  4. Скочи, после натисни скок още веднъж във въздуха за втори скок. Приземи се и опитай пак: всеки скок от земята връща скока във въздуха.
  5. Дръж Space натиснат през целия скок. Трябва да се получи един скок, а не два, защото скокът във въздуха изисква ново натискане.
  6. Включи Device Simulator в Studio (към момента на писане е бета: File, Beta Features, New Device Simulator, после рестартирай Studio) или включи стария Device Emulator в менюто Test. Избери телефон и натисни Play. Ще се появят бутоните Sprint и Dash. Дръж Sprint, докато управляваш, после дръж бутона за скок през целия скок и провери, че скокът е само един.
  7. Отвори Controller Emulator (Controller в раздела Emulation или Virtual controller в панела на Device Simulator). Дръж L3, докато се движиш, за да бягаш, натисни B за даш и A два пъти за двоен скок.
  8. Нулирай персонажа през менюто на играта. Лентата е пак пълна, в Output няма предупреждение от MovementCheck, а ако все още симулираш телефон, бутоните Sprint и Dash са на мястото си.
  9. Сега играй като измамник. Натискай превключвателя Client/Server, докато Explorer не покаже клиента, избери Humanoid на своя персонаж в Workspace и задай WalkSpeed на 60 в прозореца Properties. Походи няколко секунди: в Output ще се появи предупреждение като MovementCheck: YourName moved 60 studs/s. Върни 16, после една минута бягай и прави дашове както обикновено и провери, че Output мълчи.
  10. Ако в твоя плейс Workspace.PlayerScriptsUseInputActionSystem е Enabled, провери двойния скок още веднъж: документацията на Roblox не казва дали JumpRequest се държи по същия начин с него.

Ако не се случва изобщо нищо, отвори прозореца Output през менюто Window в Studio и потърси червена грешка от MovementClient или виж честите грешки.

Колко бързо и колко дълго: пресети по тип игра

Правилното бягане зависи от играта. Гонитба в хорър иска кратко бавно бягане, което свършва в най-неудобния момент; голяма отворена карта иска дълго, за да не скучаят играчите, докато я пресичат. Тези пресети използват същите скриптове и променят само скоростта на ходене и MovementConfig. Това са нашите начални точки, сметнати по настройките, а не измерени с играчи.

Скорост на ходене, бягане и стамина по тип игра. Времето на бягане е MAX_STAMINA / DRAIN_PER_SECOND; възстановяването е MAX_STAMINA / REGEN_PER_SECOND плюс 1 секунда REGEN_DELAY
Тип играCharacterWalkSpeedSPRINT_BONUS (скорост на бягане)DRAIN_PER_SECONDREGEN_PER_SECONDПълно бяганеОт празна до пълнаРазстояние с една лента
Това ръководство1610 (26)20155 с7.7 с130 стъда
Гонитба в хорър128 (20)25104 с11 с80 стъда
Battlegrounds и бойни игри1612 (28)15206.7 с6 соколо 187 стъда
Отворен свят или симулатор1616 (32)102510 с5 с320 стъда
Оби или паркур168 (24)без стамина: използвай ShiftToSprint
  • Скоростта на ходене се задава в StarterPlayer. Избери StarterPlayer и задай CharacterWalkSpeed (по подразбиране 16). Всеки нов персонаж започва с тази скорост, бягането добавя към нея SPRINT_BONUS, а MovementCheck също я чете, така че проверката на сървъра следва твоя избор.
  • MovementCheck се нагажда. Той позволява скоростта на ходене плюс бонуса за бягане и още една четвърт за лаг: 25 стъда в секунда за пресета за хорър, 40 за отворен свят. Нищо друго не трябва да се променя.
  • В оби бягането променя трасето. С по-бързо бягане се прескачат по-дълги пропасти. Изгради скоковете, а после провери всеки със скоростта на бягане, иначе бягането ще направи етапите твърде лесни. Ръководството за чекпойнти в оби се съчетава добре с ShiftToSprint.
  • В хорър ориентирът е убиецът. Направи преследвача малко по-бърз от скоростта на ходене и малко по-бавен от бягането, за да зависи бягството от това кога ще свърши лентата. Ръководството за хорър игра разглежда останалия цикъл.

Какво не е наред със старите скриптове за бягане

Старите туториали за бягане, даш и двоен скок често още работят, но много от тях използват похвати, които Roblox оттогава е заменил, или чупят други системи в играта ти. Ако поправяш копиран скрипт, сравни го с този списък.

Похвати от старите туториали и какво прави това ръководство вместо тях
ПохватКакъв е проблемътТова ръководство
BodyVelocity за дашаОстарял: Roblox казва да се използва LinearVelocity вместо негоLinearVelocity в режим Plane
Цикъл на RunService.RenderSteppedЗа нова работа е заменен от PreRender. Игровата логика като стамината е мястото ѝ в Heartbeat, който Roblox описва за периодични задачи като възстановяване на здраветоHeartbeat с deltaTime
Цикъл на стамината с wait()wait() е остарял в полза на task.wait() и се забавя, затова може да чака по-дълго, отколкото е поискано, и фиксиран разход за всеки wait харчи стамината неравномерноРазход и възстановяване всеки кадър с отчитане на deltaTime
UserInputService.InputBegan без проверка за чатаНатискане на Shift, докато пишеш съобщение в чата, пуска бяганетоContextActionService, който освен това добавя бутон на телефона
WalkSpeed = 16 при пускане или всеки кадърПрезаписва всяка друга скорост, например перк от геймпасПроменя WalkSpeed само в началото и в края на бягането, като добавя към текущата стойност
Бягане през RemoteEvent, за да задава WalkSpeed сървърътЕксплойтърите така или иначе си задават WalkSpeed сами, а бягането започва със закъснение за пътя дотам и обратноБягане на клиента плюс проверка на разстоянието на сървъра
Двоен скок при всеки JumpRequestJumpRequest се задейства няколко пъти за една заявка за скок, а задържаният бутон може да продължи да иска скоковеПауза от 0.25 секунди и проверка за ново натискане
UserInputService.TouchEnabled като проверка „това е телефон“Той е true на лаптопи със сензорен екранContextActionService добавя бутони на екрана на сензорни устройства без твоя собствена проверка на устройството
Humanoid:LoadAnimation за анимацията на бяганеОстарял в полза на Animator:LoadAnimationАнимацията на бягане по-долу използва Animator

Новият начин от Roblox: Input Action System

Страницата на Roblox за Input Action System взема бягането на персонажа за първи пример. Вместо извиквания на BindAction управлението се настройва в Studio: InputAction с име CharacterSprint вътре в input context в ReplicatedStorage, с един InputBinding за Left Shift, един за бутона Y на геймпада и един, свързан с бутон на екрана, който рисуваш в StarterGui. След това клиентски скрипт слуша събитията на действието Pressed и Released, като удвоява WalkSpeed при натискане и я връща при пускане.

Струва си да минеш на него, ако искаш да подреждаш управлението в Studio, а не в кода, собствен сензорен бутон вместо бутона на ContextActionService или контексти, които сменят цели набори от управление, например за меню или превозно средство. Страницата съветва и да зададеш Workspace.PlayerScriptsUseInputActionSystem на Enabled, а server authority го изисква.

Цикълът на стамината и дашът от това ръководство работят по същия начин само с Input Action System (без server authority). Остави MovementConfig, цикъла Heartbeat и dash(), изтрий двете извиквания на BindAction и техните обработчици и вместо тях свържи действията: Pressed на действието за бягане задава sprintHeld на true, а неговото Released на false, и Pressed на действието за даш извиква dash(). Продължавай да търсиш Humanoid всеки кадър, както прави MovementClient, защото примерът от документацията пази Humanoid на първия персонаж, а след прераждане той вече го няма.

Roblox тества и Character Controller Library, бета, която се включва в Beta Features и Avatar Settings в Studio. Нейната страница за собствени способности изгражда като пример даш с активен прозорец от 0.2 секунди и презареждане от 1 секунда, тоест със същия тайминг като даша от това ръководство.

Как да го разшириш: анимация, камера и пас за бягане

Анимация на бягане

Направи анимация на бягане в Animation Editor, задай ѝ приоритет Movement (Roblox го препоръчва за анимации на ходене и бягане), публикувай я и копирай ID на асета. В MovementClient създай Animation с този AnimationId, зареди я чрез Animator:LoadAnimation, като използваш Animator вътре в Humanoid на персонажа, пускай трака там, където започва бягането, и го спирай там, където свършва. Зареждай я наново за всеки нов персонаж.

Анимациите, които устройството ти пуска на твоя персонаж, се виждат от всички, ако използваш Animator, който Roblox е сложил там: траковете, заредени в Animator, създаден от LocalScript, не се репликират. Humanoid:LoadAnimation, който използват много стари туториали, е остарял.

По-широка камера по време на бягане

Малко по-широк ъгъл на видимост кара бягането да се усеща по-бързо. На същите две места направи tween на workspace.CurrentCamera.FieldOfView от стойността по подразбиране 70 до около 80, когато бягането започне, и обратно, когато свърши, например чрез TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox ограничава стойността между 1 и 120 и предупреждава, че много ниски или много високи стойности могат да дезориентират играчите. Ако ъгъла на видимост го променя и някой друг скрипт в играта, връщай с tween към намерената стойност, а не към 70.

Бързо бягане като геймпас

Ръководството за геймпасове вече работи с този скрипт: неговият перк Speed на сървъра задава WalkSpeed 24 на всеки нов персонаж, MovementClient добавя отгоре бонуса за бягане, а 34 стъда в секунда остават в границите на това, което позволява MovementCheck.

За пас, който ускорява самото бягане, добави пас FastSprint в PassConfig.ids от онова ръководство. Тогава неговият сървърен скрипт задава на играча атрибута OwnsPass_FastSprint, щом покупката бъде потвърдена. В MovementClient използвай бонус, по-голям от Config.SPRINT_BONUS, когато player:GetAttribute("OwnsPass_FastSprint") == true. В MovementCheck дай на тези играчи по-голям допуск, като четеш същия атрибут на сървъра, където играчът не може да го промени, и провери, че новата максимална скорост остава под това, което отбелязва проверката.

Едно ограничение, за което е добре да знаеш: ако друг скрипт промени WalkSpeed по средата на бягане, краят на това бягане ще върне скоростта, която е била преди него. Следващото прераждане пак ще зададе скоростта от паса, защото скриптът на геймпаса я прилага към всеки нов персонаж.

Чести грешки и решения

Отвори прозореца Output (менюто Window, после Output), преди да натиснеш Play. Повечето проблеми с тези скриптове печатат там грешка или предупреждение с името на скрипта и номера на реда.

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

MovementClient или MovementCheck чака модул, който не съществува с точно това име. Трябва да е ModuleScript с име MovementConfig директно в ReplicatedStorage. Ръководството за грешки в скриптове разглежда подробно това предупреждение.

Shift не прави нищо

Провери, че ShiftToSprint или MovementClient е LocalScript, а не Script, и че е в StarterPlayerScripts. С MovementClient за старт на бягането персонажът трябва и да върви, и да има поне 20 стамина, така че дръж Shift, докато се движиш. Ако вместо бягане се превключва Shift Lock, виж въпроса за Shift Lock по-долу.

Бягането спира след няколко секунди

Това свършва стамината: 100 стамина по 20 в секунда стигат за 5 секунди. Увеличи MAX_STAMINA или намали DRAIN_PER_SECOND в MovementConfig.

Дашът не прави нищо

Дашът изисква 25 стамина, чака 1 секунда след предишния и не прави нищо, докато седиш. Ако не е това, основният парт на персонажа ти може да няма Attachment с име RootAttachment, както се случва при някои собствени персонажи: добави го в HumanoidRootPart на твоя StarterCharacter.

Двойният скок не се задейства

DoubleJump трябва да е LocalScript в StarterCharacterScripts, а не в StarterPlayerScripts, защото чете script.Parent като персонажа. Натисни скок втори път, след като се отлепиш от земята: задържаният бутон не се брои за ново натискане, а слизането от ръб не дава скок във въздуха.

На телефона няма бутон Sprint или Dash

ContextActionService добавя своите бутони само на сензорни устройства, затова на PC без сензорен екран те никога не се виждат. Тествай с телефон в Device Simulator в Studio (това е бета: включи New Device Simulator във File, Beta Features и рестартирай Studio). BindAction може да създаде не повече от 7 сензорни бутона, така че преброй колко правят другите скриптове в играта.

MovementCheck се оплаква от честни играчи

Обичайните причини: телепорт от друг сървърен скрипт, конвейер или превозно средство, или лаг. Задавай атрибута MovementCheckSkip след своите телепорти (виж Прераждания и телепорти) и увеличи SPEED_ALLOWANCE, ако проверката все още се задейства при нормална игра.

Ускорението изчезва след бягане

Друг скрипт е променил WalkSpeed по време на бягането, а бягането, когато свърши, е върнало скоростта, която е видяло в началото. Давай ускоренията при появата на персонажа, както прави ръководството за геймпасове, за да задава прераждането отново правилната скорост.

Направи го с RoCode

Ако не ти се настройва всичко това на ръка, RoCode може да го изгради в плейса, който имаш отворен. RoCode е независим ИИ агент за Roblox Studio, не от Roblox: описваш промяната в уеб чата, а неговият плъгин за Studio създава скриптовете в твоя Explorer, така че не трябва да поставяш код.

Ти пишеш

Добави бягане със Shift с лента за стамина: скоростта на ходене плюс 10, докато Shift е задържан, 100 стамина, разход 20 в секунда, възстановяване 15 в секунда след секунда почивка, бутон Sprint на телефоните, даш с Q и двоен скок.

RoCode прави
  • Може първо да прегледа плейса ти чрез Search Scripts и Read Script, за да намери други скриптове, които променят WalkSpeed (например перк от геймпас), и бягането да се добавя към тях
  • Пише ModuleScript, LocalScript-овете и проверката на сървъра чрез Create Script
  • Казано му е да проверява компилацията на всеки написан скрипт чрез Check Script, който го компилира в Studio, без да го пуска
  • Поставя точка за отмяна преди и след всяка група промени, затова Ctrl+Z връща назад по една група

RoCode не може да прави анимацията на бягане: създай я в Animation Editor и постави нейното ID. С плъгин 3.9.11 или по-нов RoCode може да пусне плейтест на играта ти в Studio и да управлява тестов персонаж, за да провери, че всичко работи, а с плъгин 3.9.15 или по-нов тестовият персонаж може да натиска клавиши, например да държи Shift и да проверява, че WalkSpeed се е увеличила. Той сам решава кога да пуска плейтест, до 2 на изграждане плюс 1, за да провери своята поправка, и проверява само това, което сам е решил да тества, затова пробвай бягането, даша и двойния скок сам, а бутоните на телефона провери в Device Simulator в Studio. Движението е една система от много в една игра; създаването на цяла игра с RoCode върви по една система на промпт, както тук. Как RoCode се свързва със Studio.

Често задавани въпроси

Защо скриптът за бягане не работи на телефон?

Телефонът няма клавиш Shift. Свързвай бягането чрез ContextActionService:BindAction и подавай true като трети аргумент: това добавя бутон на екрана на сензорните устройства, както правят и ShiftToSprint, и MovementClient.

Трябва ли бягането да се прави на сървъра?

Не. Всяко устройство движи своя персонаж, затова WalkSpeed, зададена от сървъра, няма да спре измамник, който може да зададе своя, а новата скорост идва чак след пътя дотам и обратно, така че бягането започва със закъснение. Прави бягането на клиента, а на сървъра проверявай колко далеч наистина се движат персонажите, както в Стъпка 5. Бетата server authority на Roblox е устроена другояче и кодът за движение за нея ще трябва да се пренапише.

Защо персонажът продължава да бяга, когато пусна Shift?

Скриптът е пропуснал пускането, обикновено защото слуша само натискането. ContextActionService праща End, когато клавишът се пусне, и Cancel, когато го прихване друго свързване; MovementClient спира и при двете, а също когато свърши стамината или персонажът спре да се движи.

Как да добавя анимация на бягане?

Зареди анимацията на бягане чрез Animator в Humanoid на персонажа в същия LocalScript, пускай я, когато бягането започне, и я спирай, когато свърши. Дай ѝ приоритет Movement. Анимациите, пуснати на собствения ти персонаж, се виждат от всички.

Защо двойният скок на телефона се задейства сам?

Задържаният бутон за скок на телефона продължава да иска скокове. Смятай скока за нов само ако заявките за миг са спрели, както прави скриптът DoubleJump.

Каква е скоростта на ходене в Roblox по подразбиране?

16 стъда в секунда. Тя идва от StarterPlayer.CharacterWalkSpeed, което задава Humanoid.WalkSpeed на всеки нов персонаж. Бягането от това ръководство добавя 10, така че бягането е с 26.

Каква скорост трябва да има бягането в Roblox?

Повечето игри добавят между половин и цяла скорост на ходене: 16 става нещо между 24 и 32. Кратко бавно бягане подхожда на хорър, а дълго бързо на големи карти. Пресетите по тип игра дават за всеки скорост на ходене, бонус за бягане и числа за стамината.

Как да направя бягане със стамина?

Пази число за стамината на устройството на играча, харчи го всеки кадър по време на бягане и го възстановявай след кратка почивка, и двата пъти с отчитане на времето на кадъра, и спирай бягането, когато стигне 0. MovementClient от Стъпка 3 прави това с лента на екрана; числата са в MovementConfig.

Как да бягам с контролер в Roblox?

Свържи ButtonL3 на геймпада (натискане на левия стик) чрез ContextActionService заедно с Left Shift, както правят двата скрипта тук. ShiftToSprint прави L3 превключвател, защото да държиш стика натиснат и едновременно да управляваш с него е изморително.

Конфликт ли е бягането със Shift с Shift Lock?

Може да е. Играчите, които са включили Shift Lock в настройките на Roblox, го превключват с клавиша Shift, така че един клавиш прави две неща. В документацията на Roblox пише, че API на Shift Lock се извежда от употреба. Ако конфликтът пречи на играчите ти, изключи StarterPlayer.EnableMouseLockOption или свържи бягането в MovementClient с друг клавиш, например Left Ctrl.

Източници и какво да прочетеш

Как е проверен кодът: всеки скрипт на тази страница минава строга проверка на типовете в Luau с дефинициите на Roblox API (luau-lsp, 20 ноември 2026 г.). Проверката на типовете хваща грешки в имената на API и грешни типове, но не и грешки в логиката на играта, затова тествай всичко в Studio, преди да публикуваш.

Пробвай RoCode в своята игра.

Безплатни кредити всеки ден, без карта. Инсталирай плъгина, опиши функцията и виж какво се е появило в Studio.