Накратко
Сложи един 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. Колко бързо и колко дълго да се бяга, ще подскажат пресетите по тип игра с числа за хорър, бойни игри и отворен свят.
На тази страница
Как работи бягането в Roblox
Устройството на всеки играч движи собствения му персонаж. Клавиатурата, контролерът или сензорният екран решават накъде отива персонажът, а Roblox предава резултата на сървъра и на всички останали. Затова бягането е LocalScript, който вдига Humanoid.WalkSpeed, докато клавишът е натиснат, и това е всичко, което прави Стъпка 1. Останалата част от ръководството е това, което трябва на голяма игра около него: лента за стамина, даш, двоен скок и проверка на сървъра срещу измамници.
| Елемент | Къде се намира | Какво прави |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Стъпка 1 сама по себе си: бягане с клавиатура, телефон и геймпад, без стамина. Когато добавиш стамина и даш, го заменя MovementClient. |
ModuleScript MovementConfig | ReplicatedStorage | Числата: бонус за бягане, стамина и даш. Чете ги и LocalScript, и проверката на сървъра. |
LocalScript MovementClient | StarterPlayerScripts | Свързва Sprint и Dash с клавиш, бутон на геймпада и сензорен бутон, върти цикъла на стамината, рисува лентата и прави даша. |
LocalScript DoubleJump | StarterCharacterScripts | Дава един допълнителен скок във въздуха. Ново копие се пуска във всеки нов персонаж. |
Script MovementCheck | ServerScriptService | Измерва колко далеч всъщност се движи всеки персонаж и пише предупреждение в Output, когато някой дълго се движи по-бързо, отколкото позволяват бягането и дашът. |
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 на екрана на телефоните, а на геймпада позволява да бягаш с левия стик.
- В Explorer разгъни StarterPlayer, задръж мишката върху StarterPlayerScripts, натисни бутона + и вмъкни LocalScript с име
ShiftToSprint. - Замени съдържанието му с кода по-долу и натисни Play.
-- 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 само нулира флага.
Задържане или превключване?
| Устройство и въвеждане | Работи като | Защо |
|---|---|---|
| Клавиатура: 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 чете същия модул на сървъра, за да знае каква трябва да е скоростта на бягането и даша.
- В Explorer задръж мишката върху ReplicatedStorage, натисни бутона + и вмъкни ModuleScript.
- Преименувай го на
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_BONUS | 10 | Добавя се към WalkSpeed по време на бягане. WalkSpeed в Roblox по подразбиране е 16, затова бягането е със скорост 26 стъда в секунда. |
MAX_STAMINA | 100 | Пълна лента. |
DRAIN_PER_SECOND | 20 | Пълната лента стига за 5 секунди бягане. |
REGEN_PER_SECOND | 15 | Празната лента се пълни за около 6.7 секунди. |
REGEN_DELAY | 1 | Секунди почивка преди началото на възстановяването. |
MIN_TO_START | 20 | Стамина, нужна, за да започнеш да бягаш. |
DASH_SPEED | 60 | Стъда в секунда по време на даша. |
DASH_SECONDS | 0.2 | Колко трае дашът: около 12 стъда при 60 стъда в секунда. |
DASH_COST | 25 | Стамина за всеки даш. |
DASH_COOLDOWN | 1 | Секунди между дашовете. |
Всяка страна пуска свое копие на модула (модулът се изпълнява веднъж на всяка страна), затова играч, който променя тези числа на своето устройство, променя само своето копие. Но тук това нищо не защитава: неговото устройство и без това движи персонажа му, затова може да си даде безкрайна стамина, каквото и да има в модула. Проверката на сървъра от Стъпка 5 е изградена с това предвид.
Стъпка 3: бягане със стамина и даш
Този LocalScript прави това, което усещат играчите. Той свързва Sprint и Dash, рисува лентата за стамина, всеки кадър върти цикъла на стамината и прави даша.
- В Explorer разгъни StarterPlayer, задръж мишката върху StarterPlayerScripts и вмъкни LocalScript с име
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 слага копие на скриптовете от този контейнер във всеки персонаж при появата му и тези копия не оцеляват след прераждане, затова всеки живот започва с нов скрипт и нищо не се пренася от предишния.
- В Explorer разгъни StarterPlayer, задръж мишката върху StarterCharacterScripts и вмъкни LocalScript с име
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.
- Задръж мишката върху ServerScriptService и вмъкни Script с име
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) и следващата проверка ще започне да мери от новата позиция, вместо да отбележи скока:
- В системата от рундове веднага след
character:PivotTo(...)вstartRound. - В скрипта за чекпойнти в оби веднага след всяко
character:PivotTo(...), което премества играча на неговия чекпойнт.
Падовете и менютата от ръководството за телепорти и падът Finish от ръководството за първата игра вече го задават след всяко преместване.
Брои се само стойността от сървъра. Атрибут, който играчът задава на своето устройство, остава на това устройство (виж какво се репликира и какво не), затова измамник не може да изключи проверката с него.
Решение за в бъдеще: server authority
Документацията на Roblox за сигурност нарича модела server authority, към момента на писане в бета, най-надеждния начин да се спрат експлойтите в движението. Източник на истината става сървърът, а устройствата на играчите само съобщават своето въвеждане, което според документацията не позволява на спийдхаковете да работят, защото на устройството никога не се вярва да съобщава собствената си позиция.
Преминаването е пренаписване, а не настройка. В този модел движението се смята от сървъра, затова WalkSpeed или LinearVelocity, зададени само от LocalScript, се отменят, когато пристигне състоянието от сървъра. В документацията на Roblox пише, че основната логика трябва да работи във функции на RunService:BindToSimulation() в ModuleScript, който се пуска и от клиента, и от сървъра. Моделът изисква и няколко настройки на Workspace, включително PlayerScriptsUseInputActionSystem, така че управлението ти също ще се премести на Input Action System. Остави версията от това ръководство, докато не пренесеш бягането, стамината и даша в тази схема. Дотогава проверка по разстояние като тази е точно това, което описва разделът на Roblox за проверка на движението.
Стъпка 6: тествай на всяко устройство
- Натисни Play и дръж Shift, докато вървиш. Скоростта расте от 16 до 26 стъда в секунда, а зелената лента в долната част на екрана намалява. След около 5 секунди тя е празна и пак вървиш с нормален ход.
- Пусни Shift. След 1 секунда лентата започва да се пълни. Докато не се напълни до една пета, Shift не прави нищо.
- Натисни Q, докато вървиш: стрелваш се малко напред и една четвърт от лентата изчезва. Натисни Q веднага още веднъж и нищо няма да стане, докато не мине секунда. Ако дашът изглежда твърде къс или дълъг, промени
DASH_SPEEDилиDASH_SECONDSв MovementConfig. - Скочи, после натисни скок още веднъж във въздуха за втори скок. Приземи се и опитай пак: всеки скок от земята връща скока във въздуха.
- Дръж Space натиснат през целия скок. Трябва да се получи един скок, а не два, защото скокът във въздуха изисква ново натискане.
- Включи Device Simulator в Studio (към момента на писане е бета: File, Beta Features, New Device Simulator, после рестартирай Studio) или включи стария Device Emulator в менюто Test. Избери телефон и натисни Play. Ще се появят бутоните Sprint и Dash. Дръж Sprint, докато управляваш, после дръж бутона за скок през целия скок и провери, че скокът е само един.
- Отвори Controller Emulator (Controller в раздела Emulation или Virtual controller в панела на Device Simulator). Дръж L3, докато се движиш, за да бягаш, натисни B за даш и A два пъти за двоен скок.
- Нулирай персонажа през менюто на играта. Лентата е пак пълна, в Output няма предупреждение от MovementCheck, а ако все още симулираш телефон, бутоните Sprint и Dash са на мястото си.
- Сега играй като измамник. Натискай превключвателя Client/Server, докато Explorer не покаже клиента, избери Humanoid на своя персонаж в Workspace и задай WalkSpeed на 60 в прозореца Properties. Походи няколко секунди: в Output ще се появи предупреждение като
MovementCheck: YourName moved 60 studs/s. Върни 16, после една минута бягай и прави дашове както обикновено и провери, че Output мълчи. - Ако в твоя плейс
Workspace.PlayerScriptsUseInputActionSystemе Enabled, провери двойния скок още веднъж: документацията на Roblox не казва далиJumpRequestсе държи по същия начин с него.
Ако не се случва изобщо нищо, отвори прозореца Output през менюто Window в Studio и потърси червена грешка от MovementClient или виж честите грешки.
Колко бързо и колко дълго: пресети по тип игра
Правилното бягане зависи от играта. Гонитба в хорър иска кратко бавно бягане, което свършва в най-неудобния момент; голяма отворена карта иска дълго, за да не скучаят играчите, докато я пресичат. Тези пресети използват същите скриптове и променят само скоростта на ходене и MovementConfig. Това са нашите начални точки, сметнати по настройките, а не измерени с играчи.
| Тип игра | CharacterWalkSpeed | SPRINT_BONUS (скорост на бягане) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Пълно бягане | От празна до пълна | Разстояние с една лента |
|---|---|---|---|---|---|---|---|
| Това ръководство | 16 | 10 (26) | 20 | 15 | 5 с | 7.7 с | 130 стъда |
| Гонитба в хорър | 12 | 8 (20) | 25 | 10 | 4 с | 11 с | 80 стъда |
| Battlegrounds и бойни игри | 16 | 12 (28) | 15 | 20 | 6.7 с | 6 с | около 187 стъда |
| Отворен свят или симулатор | 16 | 16 (32) | 10 | 25 | 10 с | 5 с | 320 стъда |
| Оби или паркур | 16 | 8 (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 сами, а бягането започва със закъснение за пътя дотам и обратно | Бягане на клиента плюс проверка на разстоянието на сървъра |
Двоен скок при всеки JumpRequest | JumpRequest се задейства няколко пъти за една заявка за скок, а задържаният бутон може да продължи да иска скокове | Пауза от 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 и двоен скок.
- Може първо да прегледа плейса ти чрез 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.
Източници и какво да прочетеш
- Roblox Creator Docs: ContextActionService (на английски). BindAction, сензорни бутони, лимитът от 7 бутона и защо в повечето случаи е по-добър от InputBegan
- Roblox Creator Docs: Humanoid (на английски). WalkSpeed и бележката за сигурност, MoveDirection, StateChanged и ChangeState с пример за двоен скок
- Roblox Creator Docs: LinearVelocity (на английски). режим Plane, допирателни оси и MaxForce
- Roblox Creator Docs: Mover constraints (на английски). преминаване от остарелия BodyVelocity към LinearVelocity
- Roblox Creator Docs: UserInputService (на английски). JumpRequest и защо му трябва debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (на английски). какво контролира клиентът, проверки на разстоянието, дупчести кофи и изключения за телепорти
- Roblox Creator Docs: Server authority model (на английски). моделът с движение на сървъра, BindToSimulation и нужните му настройки на Workspace
- Roblox Creator Docs: Input Action System (на английски). примерът Character Sprint с InputAction и InputBinding
- Roblox Creator Docs: Custom abilities (на английски). способността даш в Character Controller Library
- Roblox Creator Docs: Studio testing modes (на английски). Device Simulator и Controller Emulator
Как е проверен кодът: всеки скрипт на тази страница минава строга проверка на типовете в Luau с дефинициите на Roblox API (luau-lsp, 20 ноември 2026 г.). Проверката на типовете хваща грешки в имената на API и грешни типове, но не и грешки в логиката на играта, затова тествай всичко в Studio, преди да публикуваш.