Röviden
Tegyél egyetlen LocalScriptet a StarterPlayerScriptsbe, amely a Sprint műveletet ezzel köti be: ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Amíg a Shift nyomva van, adj 10-et a Humanoid.WalkSpeed értékhez (a 16-ból 26 lesz), elengedéskor pedig állítsd vissza az előző értéket. A true argumentum Sprint gombot ad az érintőképernyőkhöz, és az útmutató scriptjében ez a gomb és a kontroller L3 gombja be- és kikapcsolja a futást, nem nyomva tartással működik.
- Az aktuális WalkSpeedhez adj hozzá, ne állítsd 26-ra, hogy egy game passból jövő gyorsítás megmaradjon.
- A futás a játékos eszközén működik. A szerver nem kényszerítheti ki a WalkSpeed értékét; csak azt tudja mérni, milyen messzire mozognak a karakterek, és jelezni azt a sebességet, amelyet futással nem lehet megmagyarázni.
- A staminacsíkot, a dasht és a dupla ugrást ugyanerre az ötletre építve a 2-4. lépés adja hozzá. Hogy milyen gyorsan és meddig fuss, azt a játéktípus szerinti presetek mutatják meg, számokkal horrorhoz, harchoz és nyílt világhoz.
Ezen az oldalon
Hogyan működik a futás Robloxban
Minden játékos eszköze a saját karakterét mozgatja. A billentyűzet, a kontroller vagy az érintőképernyő dönti el, merre megy a karakter, a Roblox pedig továbbítja az eredményt a szervernek és mindenki másnak. Ezért a futás egy LocalScript, amely megemeli a Humanoid.WalkSpeed értékét, amíg a billentyű nyomva van, és ennyit csinál az 1. lépés. Az útmutató többi része az, amire egy nagy játéknak szüksége van köré: staminacsík, dash, dupla ugrás és szerveroldali ellenőrzés a csalók ellen.
| Elem | Hol van | Mit csinál |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Az 1. lépés önmagában: futás billentyűzeten, telefonon és kontrolleren, stamina nélkül. Amikor hozzáadod a staminát és a dasht, a MovementClient váltja fel. |
ModuleScript MovementConfig | ReplicatedStorage | Számok: futási bónusz, stamina és dash. A LocalScript és a szerveroldali ellenőrzés is olvassa őket. |
LocalScript MovementClient | StarterPlayerScripts | A Sprint és a Dash műveletet billentyűhöz, kontrollergombhoz és érintőgombhoz köti, futtatja a stamina ciklusát, kirajzolja a csíkot, és végrehajtja a dasht. |
LocalScript DoubleJump | StarterCharacterScripts | Egy extra ugrást ad a levegőben. Minden új karakterben egy új példány indul. |
Script MovementCheck | ServerScriptService | Méri, milyen messzire mozog valójában minden karakter, és figyelmeztetést ír az Outputba, ha valaki hosszan gyorsabban mozog, mint amit a futás és a dash megenged. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Ha a Script és a LocalScript közötti különbség új neked, a Script, LocalScript és ModuleScript elmagyarázza, hol fut az egyes típus, és miért.
1. lépés: futás Shiftre egyetlen LocalScriptben
Ha csak gyorsabb futás kell, amíg a Shift nyomva van, elég ez az egy script. A telefonoknak ráadásul Sprint gombot ad a képernyőn, kontrolleren pedig a bal karral lehet futni.
- Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterPlayerScripts fölé, nyomd meg a + gombot, és szúrj be egy LocalScriptet
ShiftToSprintnéven. - Cseréld le a tartalmát az alábbi kódra, és nyomd meg a Play gombot.
-- LocalScript a StarterPlayer > StarterPlayerScripts alatt, ShiftToSprint néven.
-- Tartsd nyomva a Left Shiftet a futáshoz. Kontrolleren nyomd be a bal kart (L3), hogy
-- be- vagy kikapcsold a futást. Telefonon nyomd meg a Sprint gombot a be- vagy kikapcsoláshoz.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Beállítások
local SPRINT_BONUS = 10 -- futás közben hozzáadódik a WalkSpeedhez (a 16-ból 26 lesz)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: a gombot nyomva kell tartani
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- a WalkSpeed, amelyre vissza kell térni
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
-- Megjegyezzük az aktuális sebességet, és ahhoz adunk hozzá, hogy egy másik script gyorsítása megmaradjon
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
-- Nyomva tartás: futás, amíg a billentyű vagy gomb le van nyomva
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
-- Kapcsoló: minden nyomás be- vagy kikapcsolja a futást
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Egyetlen hívás köti be a billentyűt, a kontrollergombot és érintőképernyőn a képernyőgombot
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- Az új karakter gyaloglással kezd: a Humanoidjának már normál WalkSpeedje van
player.CharacterAdded:Connect(function()
sprinting = false
end)
A SPRINT_BONUS módosításával gyorsíthatod vagy lassíthatod a futást. Állítsd a TOGGLE_ON_TOUCH_AND_GAMEPAD értékét false-ra, hogy a telefonos gomb és az L3 úgy működjön, mint a Shift: csak nyomva tartás közben fuss.
A BindAction egyetlen műveletet köt a Left Shifthez és a kontroller L3 gombjához, a harmadik argumentuma, a true, pedig gombot ad az érintőképernyőkhöz; a SetTitle ráírja: "Sprint". A kezelő magát a bemenetet is megkapja, így meg tudja különböztetni a billentyűzetes nyomást a kontrollertől vagy az érintőgombtól. Amikor a futás elindul, a script megjegyzi az aktuális WalkSpeedet, és hozzáadja a SPRINT_BONUS értéket; amikor véget ér, visszaállítja a megjegyzett értéket. Egy másik script által beállított sebesség, például a game pass útmutató Speed bónusza, megmarad. Az új karakter normál WalkSpeeddel kezd, ezért a CharacterAdded kezelő csak a jelzőt állítja vissza.
Nyomva tartás vagy kapcsoló?
| Eszköz és bemenet | Így működik | Miért |
|---|---|---|
| Billentyűzet: Left Shift | Nyomva tartás | Mozgás közben könnyű nyomva tartani a billentyűt, az elengedés pedig azonnal leállítja a futást. |
| Kontroller: a bal kar benyomása (L3) | Kapcsoló | Fárasztó benyomva tartani a kart, és közben kormányozni vele. |
| Telefon vagy tablet: Sprint gomb a képernyőn | Kapcsoló | A hüvelykujj, amely a gombot tartja, közben nem tudja megnyomni a Jump gombot. |
A teszteléshez nyomd meg a Play gombot, és séta közben tartsd nyomva a Shiftet: a sebesség 16-ról 26 stud/másodpercre nő, elengedéskor pedig lelassulsz. Telefonhoz válassz ki egy telefont a Studio Device Simulatorában, nyomd meg a Play gombot, és nyomd meg egyszer a Sprint gombot az indításhoz, még egyszer a leállításhoz. Kontrollerhez nyisd meg a Controller Emulatort játékteszt közben, és nyomd meg az L3-at. Az eszközönkénti ellenőrzések teljes listája a 6. lépésben van.
A 2. és a 3. lépés ezt a scriptet egy másikra cseréli, staminacsíkkal és dash-sel. A 4. és az 5. lépés hozzáadja a dupla ugrást és a szerveroldali ellenőrzést, és bármelyik scripttel működik.
2. lépés: a stamina és a dash számai egy modulban
Egy véget érő futáshoz a 2. és a 3. lépés a ShiftToSprintet egy nagyobb LocalScriptre cseréli staminacsíkkal és dash-sel. Előbb töröld a ShiftToSprintet: mindkét script beköti a Sprint műveletet.
Minden szám egyetlen ModuleScriptben van, így a mozgás érzete egy helyen hangolható. A MovementClient minden játékos eszközén olvassa őket, a MovementCheck pedig ugyanezt a modult olvassa a szerveren, hogy tudja, mekkora legyen a futás és a dash sebessége.
- Az Explorerben vidd az egeret a ReplicatedStorage fölé, nyomd meg a + gombot, és szúrj be egy ModuleScriptet.
- Nevezd át erre:
MovementConfig, és cseréld le a tartalmát az alábbi kódra.
-- Egy számkészlet a mozgás LocalScriptjének és a szerveroldali sebességellenőrzésnek.
local MovementConfig = {
SPRINT_BONUS = 10, -- hozzáadódik az aktuális WalkSpeedhez: a 16-ból (a Roblox alapértéke) 26 lesz
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 másodperc futás egy teli csíkkal
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- másodpercek a futás vége után, mielőtt a stamina elkezd visszatöltődni
MIN_TO_START = 20, -- a futás indításához szükséges stamina, hogy az üres csík ne villogjon
DASH_SPEED = 60, -- stud/másodperc a dash alatt
DASH_SECONDS = 0.2, -- így a dash körülbelül 12 studot tesz meg
DASH_COST = 25, -- stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Beállítás | Érték | Hatás |
|---|---|---|
SPRINT_BONUS | 10 | Futás közben hozzáadódik a WalkSpeedhez. A Roblox alapértelmezett WalkSpeedje 16, ezért a futás 26 stud/másodperc. |
MAX_STAMINA | 100 | Teli csík. |
DRAIN_PER_SECOND | 20 | Egy teli csík 5 másodperc futásra elég. |
REGEN_PER_SECOND | 15 | Az üres csík nagyjából 6,7 másodperc alatt telik fel. |
REGEN_DELAY | 1 | Pihenő másodpercek a visszatöltődés kezdete előtt. |
MIN_TO_START | 20 | A futás indításához szükséges stamina. |
DASH_SPEED | 60 | Stud/másodperc a dash alatt. |
DASH_SECONDS | 0.2 | Meddig tart a dash: körülbelül 12 stud 60 stud/másodpercnél. |
DASH_COST | 25 | Stamina minden dashért. |
DASH_COOLDOWN | 1 | Másodpercek a dashek között. |
Mindkét oldal a modul saját példányát futtatja (a modul mindkét oldalon egyszer fut le), ezért ha egy játékos a saját eszközén átírja ezeket a számokat, csak a saját példányát változtatja meg. De itt ez semmit sem véd: az eszköze úgyis a karakterét mozgatja, ezért végtelen staminát adhat magának, bármi is van a modulban. Az 5. lépés szerveroldali ellenőrzése ezt figyelembe véve épül fel.
3. lépés: futás staminával és dash
Ez a LocalScript csinálja azt, amit a játékosok éreznek. Beköti a Sprint és a Dash műveletet, kirajzolja a staminacsíkot, minden képkockában futtatja a stamina ciklusát, és végrehajtja a dasht.
- Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterPlayerScripts fölé, és szúrj be egy LocalScriptet
MovementClientnéven. - Cseréld le a tartalmát az alábbi kódra.
-- Tartsd nyomva a Shiftet (vagy az L3-at, vagy a telefonos Sprint gombot), hogy fuss, amíg van stamina.
-- Nyomd meg a Q-t (vagy a B-t, vagy a Dash gombot), hogy dasht csinálj a mozgás irányába.
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 -- a WalkSpeed, amelyre vissza kell térni, amikor a futás véget ér
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Staminacsík: egy keret kitöltéssel, amelynek a szélessége a megmaradt staminával egyenlő
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
-- Futás: itt csak egy jelző van; az alábbi Heartbeat ciklus minden képkockában eldönti, kell-e futni
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Csak a lenyomás és az elengedés változtat rajta: az érintőgombon csúszó ujj Change-et küld
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()
-- Ülve nincs dash: az ülő karakter az üléshez van hegesztve, így az egész járművet lökné meg
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 -- szüneteltetjük a visszatöltődést, ahogy a futás is teszi
-- Dash arra, amerre a játékos mozog, vagy amerre néz, ha egy helyben áll
local direction = humanoid.MoveDirection
if direction.Magnitude < 0.1 then
direction = rootPart.CFrame.LookVector
end
direction = Vector3.new(direction.X, 0, direction.Z).Unit
-- A LinearVelocity Plane módban tartja a vízszintes sebességet, és nem zavarja a gravitációt
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
-- Minden hívás beköti a billentyűt, a kontrollergombot és érintős eszközökön a képernyőgombot
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")
-- Minden képkockában: futás és mozgás közben fogyasztjuk a staminát, rövid pihenő után visszatöltjük
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
-- A WalkSpeedet csak a futás elején és végén változtatjuk, hogy egy másik script
-- által beállított sebesség (például egy sebességpass) megmaradjon, és a futás ahhoz adódjon hozzá
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)
-- Az új karakter teli staminával kezd, és semmi sincs nyomva
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- az új Humanoid normál WalkSpeeddel kezd
end)
A staminacsík kódból jön létre, a ResetOnSpawn értéke false, ezért respawn után is a képernyőn marad, az alul lévő CharacterAdded kezelő pedig minden új karakternél újra feltölti. A type Config sorok leírják, mit ad vissza a modul, hogy a szigorú típusellenőrzés elkapja a beállítás nevében lévő elírást; játék közben semmit sem változtatnak.
Billentyűzet, kontroller és telefonos gomb egyetlen hívással
A ContextActionService:BindAction megkapja a művelet nevét, a kezelőfüggvényt, azt, hogy kell-e érintőgombot létrehozni, aztán a bemeneteket. Ha harmadik argumentumként true-t adsz át, a ContextActionService érintős eszközökön gombot tesz a képernyőre, a játékos PlayerGui mappájában lévő ContextActionGui nevű ScreenGui-ba. A SetTitle ráírja ezekre a gombokra: "Sprint" és "Dash". A BindAction legfeljebb 7 érintőgombot hozhat létre, ezért figyelj a számukra, ha a játék más scriptjei is használják.
A kezelő megkapja a bemenet állapotát: lenyomáskor Begin, elengedéskor End. Az onSprint csak megjegyzi, hogy a Sprint nyomva van-e. Elengedésnek számítja a Cancel-t is, amelyet a ContextActionService akkor küld, amikor egy másik kötés elveszi a bemenetet, és figyelmen kívül hagyja a Change-et, amelyet egy érintőgombon mozgó ujj küldhet. Mindkét kezelő Pass-t ad vissza, így az ugyanazon a billentyűn lévő következő kötés is megkapja a bemenetet.
A Roblox ContextActionService leírása a legtöbb esetben ezt javasolja a UserInputService.InputBegan helyett. A példája: egy autódudálás a H billentyűn, amelynek nem szabad szólnia, amíg a játékos a chatbe ír. Egy kötés csak addig sül el, amíg az a legutóbbi az adott bemenetre, ezért amikor a chat elveszi a billentyűzetet, semmit sem kell ellenőrizned. Kontrollerbemenetek: ButtonL3 (a bal kar benyomása, mozgás közben tartják) és ButtonB. A Roblox saját futáspéldája a ButtonY gombot használja, ezért cseréld le a KeyCode-ot a BindActionben, ha a játékodnak így kényelmesebb.
A stamina ciklusa
A RunService.Heartbeat minden képkockában a fizikai lépés után sül el, és átadja a deltaTime értéket, az előző képkocka óta eltelt másodperceket. Ha ezzel szorzod a fogyás és a visszatöltődés sebességét, egy teli csík 5 másodpercig tart, akár 30, akár 240 képkocka/másodperccel fut a játék.
A ciklus minden képkockában eldönti, futnia kell-e a karakternek: a Sprint nyomva van, a karakter megy (a Humanoid.MoveDirection nullvektor, amikor áll), és van még stamina. A futás indításához legalább MIN_TO_START (20) kell; a folytatáshoz bármi elég, ami 0-nál több. E rés nélkül egy üres csík, amely minden képkockában kicsit töltődik, minden képkockában be- és kikapcsolná a futást. A visszatöltődés REGEN_DELAY (1 másodperc) után kezdődik az utolsó futás vagy dash óta, ezért a csík kiürítése után a játékos nagyjából 2,3 másodpercet vár, mielőtt újra futhat.
A WalkSpeed csak abban a képkockában változik, amikor a futás elkezdődik vagy véget ér. Induláskor a script megjegyzi az aktuális WalkSpeedet, és hozzáadja a SPRINT_BONUS értéket; a végén visszaállítja a megjegyzett értéket. Ezért egy másik script által beállított sebesség megmarad: a game pass útmutató Speed bónusza 24-re állítja a WalkSpeedet, és ezzel a scripttel a tulajdonosai 34-gyel futnak. Egy script, amely minden képkockában vagy minden elengedéskor WalkSpeed = 16 értéket ír, észrevétlenül semmissé tenné ezt a bónuszt.
A dash
A dash arra löki a karaktert, amerre mozog, vagy arra, amerre néz, ha egy helyben áll, és az irányt kiegyenlíti, hogy soha ne nézzen felfelé vagy lefelé. 25 staminába kerül, a futáshoz hasonlóan szünetelteti a visszatöltődést, és 1 másodperces visszatöltési ideje van. A talajt nem ellenőrzi, ezért a levegőben is működik, ami jól megy a dupla ugráshoz. Amíg a karakter ül, a dash semmit sem csinál: az ülő karakter az üléshez van hegesztve, és egy járműben a lökés az egész járművet elmozdíthatná.
A lökés egy LinearVelocity constraint a gyökérpart RootAttachment elemén. Plane módban, az X és Z tengellyel 60 stud/másodperces vízszintes sebességet tart, a függőlegeshez pedig nem nyúl, így a gravitáció működik, és egy párkányról induló dash rendesen leesik. A MaxForce értéke math.huge, így a lökést semmi sem korlátozza. A Debris:AddItem a DASH_SECONDS után megsemmisíti a constraintet anélkül, hogy a scriptnek várnia kellene, ezért a dash 0,2 másodpercig tart, ezen a sebességen körülbelül 12 studot.
A régi útmutatók a BodyVelocity-t használják, amelyet a Roblox elavultnak jelölt azzal a megjegyzéssel, hogy helyette LinearVelocityt használj. A trükkjét, a nulla MaxForce értéket az egyik tengelyen, a LinearVelocity Line, Plane és Vector módjai váltják fel. Mivel a játékos eszköze maga szimulálja a karakterét, a LocalScript által létrehozott constraint mozgatja, és a többi játékos ugyanúgy látja a dasht, mint bármilyen más mozgást.
A Roblox saját UI útmutatója pontosan így, a humanoid.RootPart.RootAttachment elemhez rögzíti a constraintet. Ha a játékodban saját karakter van, amelynek a gyökérpartján nincs RootAttachment nevű Attachment, a dash semmit sem csinál: add hozzá a StarterCharactered HumanoidRootPartjához.
4. lépés: dupla ugrás
A dupla ugrás saját LocalScriptben él a StarterCharacterScripts alatt. A Roblox spawnoláskor minden karakterbe bemásolja az ebben a tárolóban lévő scripteket, és ezek a példányok nem élik túl a respawnt, ezért minden élet friss scripttel indul, és semmi sem kerül át az előzőből.
- Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterCharacterScripts fölé, és szúrj be egy LocalScriptet
DoubleJumpnéven. - Cseréld le a tartalmát az alábbi kódra.
-- Egy extra ugrást ad a levegőben. Minden új karakternél újraindul,
-- így respawn után semmi sem kerül át.
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 -- a JumpRequest egy nyomásra többször is elsül
local NEW_PRESS_GAP = 0.1 -- a nyomva tartott ugrógomb tovább küldi a JumpRequestet; ilyen hosszú szünet azt jelenti, hogy elengedték
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
-- A talajról indított ugrás (nem a mi levegőbeli ugrásaink egyike) visszaadja a levegőbeli ugrásokat
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- A JumpRequest akkor sül el, amikor a játékos ugrást kér, például a Space-szel vagy a telefon ugrógombjával
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Csak egy új nyomás ugrik újra, hogy a nyomva tartott gomb ne pazarolja el a levegőbeli ugrást
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)
Hármas ugráshoz állítsd az EXTRA_JUMPS értékét 2-re.
A script a Humanoid.StateChanged eseményen keresztül figyeli a karakter állapotát. A Jumping állapotba való átmenet, amely nem a Freefall állapotból jött, talajról indított ugrás, ezért levegőbeli ugrást ad, a Landed pedig újra elveszi. Ha lelépsz egy párkányról, a karakter ugrás nélkül kerül Freefall állapotba, ezért nem kap levegőbeli ugrást. Ha ott is kell, a jumpsLeft értéket a Freefall állapotba való átmenetkor is állítsd be, bármely állapotból, kivéve a Jumpingot.
A UserInputService.JumpRequest akkor sül el, amikor a játékos ugrást kér, például a Space-szel vagy a telefon ugrógombjával. A Roblox leírása figyelmeztet, hogy egy ugráskérésre többször is elsül, és debounce-ot javasol, ezért a script az utolsó ugrás utáni 0,25 másodpercben figyelmen kívül hagyja a kéréseket. A nyomva tartott ugrógomb is kérhet tovább ugrásokat, és abban a pillanatban elpazarolná a levegőbeli ugrást, amikor a karakter elhagyja a talajt, ezért egy kérés csak 0,1 másodperc kérés nélküli szünet után számít új nyomásnak.
Maga a levegőbeli ugrás ez: Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). A Roblox leírása szerint olyan eszközön futó LocalScriptből kell hívni, amelynek hálózati tulajdonjoga van a karakter felett, ez pedig alapértelmezésben a játékos saját eszköze, nem a szerver. A ChangeState leírásának kódpéldája épp egy dupla ugrás.
5. lépés: a speedhack elkapása a szerveren
A futásról szóló útmutatók gyakran megállnak a kliensnél. Egy szerveroldali Script nem bízhat a játékos WalkSpeed értékében, mert az exploiterek a saját eszközükön megváltoztatják, de látja, hol köt ki a karakterük. A MovementCheck ezt másodpercenként kétszer méri, és figyelmeztetést ír az Outputba, ha valaki hosszan gyorsabban mozog, mint amit a futás és a dash megenged. A futás és a dash számait a MovementConfigból olvassa, ezért add hozzá ezt a modult a 2. lépésből akkor is, ha a ShiftToSprintet hagytad meg.
- Vidd az egeret a ServerScriptService fölé, és szúrj be egy Scriptet
MovementChecknéven. - Cseréld le a tartalmát az alábbi kódra.
-- A játékosok eszközei mozgatják a karaktereiket, ezért egy exploiter bármilyen WalkSpeedet beállíthat.
-- Ez az ellenőrzés méri, milyen messzire mozog valójában minden karakter, és az Outputba ír,
-- ha valaki hosszan gyorsabban mozog, mint amit a futás és a dash megenged. Csak figyelmeztet:
-- a lag, a teleportok és a futószalagok túllépésnek tűnhetnek, ezért hangold be, mielőtt bárkit büntetnél.
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 -- másodperc
-- A futás sebessége plusz tartalék a lagra. Növeld meg, ha gyorsításokat árulsz.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- tartalék egy-két dashre
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- milyen gyorsan bocsátjuk meg a korábbi dasheket
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- a gyökérpart, amelyen a lastPosition mérve lett
local excess: { [Player]: number } = {} -- a tűréshatár feletti studok, fokozatosan megbocsátva
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
-- A respawn új gyökérpart, a szerveroldali teleport (kör kezdete, checkpoint) pedig
-- beállítja az alábbi attribútumot: újrakezdjük a mérést, nem jelezzük az ugrást
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
-- Csak a vízszintes mozgás: gyorsan esni nem csalás
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
A figyelmeztetés a Studióban az Outputban jelenik meg. Élő játékban a Developer Console szervernaplójába kerül, amelyet a játék tulajdonosaként olvashatsz: lásd a kimenet élő játékban részt.
Mit mér
A script félmásodpercenként beolvassa minden karakter gyökérpartjának pozícióját, és méri, mennyit mozdult el vízszintesen az előző ellenőrzés óta. A magasságot figyelmen kívül hagyja, így az esések és az ugrások soha nem számítanak; a Roblox mozgásellenőrzési tanácsa ugyanezt az XZ síkra vetítést javasolja olyan játékokhoz, ahol a talajon járnak. A tűréshatár az alapértelmezett gyaloglási sebesség plusz a futási bónusz, plusz még egy negyed a lagra: 32,5 stud/másodperc. Az ezen felüli távolság egy „lyukas vödörbe” (leaky bucket) kerül, egy gyűjtőbe, amelyről a Roblox dokumentációja azt írja, hogy sok fejlesztőnek jól beválik a rövid kitörésekhez. A vödör minden ellenőrzéskor 3 studot veszít, a script pedig akkor figyelmeztet, ha 24 studnál több van benne, ez nagyjából két dashnyi tartalék.
| Csaló | Mit csinál a MovementCheck |
|---|---|
| 100-ra állítja a WalkSpeedet | Nagyjából egy másodperc futás után figyelmeztet |
| 50-re állítja a WalkSpeedet | Nagyjából 2,5 másodperc futás után figyelmeztet |
| Visszatöltési idő nélkül, egymás után dashel (60 stud/másodperc) | Nagyjából 1,5 másodperc után figyelmeztet |
| Egyszerre 43 studnál messzebbre teleportál | A következő ellenőrzéskor figyelmeztet |
| Legfeljebb 38 stud/másodperccel fut, nagyjából másfélszer gyorsabban a futásnál | Semmit: 38,5 stud/másodperc alatt a vödör ugyanolyan gyorsan ürül, ahogy telik |
| Átírja a saját MovementConfigját a végtelen staminához | Semmit: a 26 stud/másodperces futás akármeddig megengedett |
| Repül, korlátlanul ugrál vagy átmegy a falakon | Semmit: az ellenőrzés figyelmen kívül hagyja a magasságot, és nem nézi az ütközéseket |
Vagyis az ellenőrzés elkapja a durva csalásokat, amelyeknél a játékos észrevehetően gyorsabb mindenki másnál, a finomakat viszont átengedi. Ez egy távolságalapú ellenőrzés őszinte határa, és ez az oka annak, hogy a Roblox valami erősebbet készít (lásd lent a server authority részt).
Miért csak figyelmeztet
A Roblox dokumentációja megjegyzi, hogy az egyszerű sebességellenőrzések megjelölhetik az instabil kapcsolatú becsületes játékosokat, és elromlanak a járműves vagy más összetett mozgású játékokban. A lagugrások, a futószalagok, a járművek, a karaktereket ellökő robbanások és a saját teleportjaid túllépésnek tűnhetnek, ezért a script csak figyelmeztetést ír ki. Figyeld az Outputot, amíg te és a tesztelőid normálisan játszotok, növeld meg a SPEED_ALLOWANCE értékét, ha becsületes játékosok akadnak fenn rajta, és büntetést, például a játékos visszahelyezését, csak akkor adj hozzá, amikor az ellenőrzés normál játék közben hallgat. Ha a játékodban robbanások lökik el a karaktereket, hagyd ki azokat a játékosokat is, akiknek a Humanoidján nem maradt életerő.
Respawnok és teleportok
A respawn új gyökérpartot hoz létre, és a script, amikor meglátja, újrakezdi a mérést, ezért a spawnponttól messze történő halál soha nem számít túllépésnek. A saját szerverscriptjeid által végzett teleportokhoz kivétel kell, ahogy a Roblox dokumentációja mondja minden teleportos játékhoz. Teleport után add hozzá ezt: player:SetAttribute("MovementCheckSkip", true), és a következő ellenőrzés az új pozíciótól kezdi a mérést, ahelyett hogy jelezné az ugrást:
- A körrendszerben közvetlenül a
character:PivotTo(...)után astartRoundfüggvényben. - Az obby checkpointscriptjében közvetlenül minden olyan
character:PivotTo(...)után, amely a játékost a checkpointjára viszi.
A teleportokról szóló útmutató padjai és menüi, valamint az első játékról szóló útmutató Finish padja már minden mozgatás után beállítják.
Csak a szerverről jövő érték számít. Az az attribútum, amelyet a játékos a saját eszközén állít be, azon az eszközön marad (lásd: mi replikálódik, és mi nem), ezért egy csaló nem tudja vele kikapcsolni az ellenőrzést.
Megoldás a jövőre: server authority
A Roblox biztonsági dokumentációja a server authority modellt, amely e sorok írásakor bétában van, a mozgási exploitok megállításának legmegbízhatóbb módjának nevezi. Az igazság forrása a szerver lesz, a játékosok eszközei pedig csak a bemenetüket jelentik, ami a dokumentáció szerint megakadályozza a speedhackek működését, mert az eszközre soha nem bízzák, hogy a saját pozícióját jelentse.
Az átállás újraírás, nem hangolás. Ebben a modellben a mozgást a szerver számolja, ezért a csak LocalScript által beállított WalkSpeed vagy LinearVelocity felülíródik, amikor megérkezik az állapot a szerverről. A Roblox dokumentációja szerint a fő logikának RunService:BindToSimulation() függvényekben kell futnia egy olyan ModuleScriptben, amelyet a kliens és a szerver is futtat. A modellhez néhány Workspace beállítás is kell, köztük a PlayerScriptsUseInputActionSystem, így az irányításod is átköltözik az Input Action Systemre. Maradj az útmutató változatánál, amíg át nem viszed a futást, a staminát és a dasht ebbe a felépítésbe. Addig egy ilyen távolságalapú ellenőrzés az, amit a Roblox mozgásellenőrzésről szóló része leír.
6. lépés: teszteld minden eszközön
- Nyomd meg a Play gombot, és séta közben tartsd nyomva a Shiftet. A sebesség 16-ról 26 stud/másodpercre nő, a képernyő alján lévő zöld csík pedig fogy. Nagyjából 5 másodperc után üres, és újra gyalogolsz.
- Engedd el a Shiftet. 1 másodperc múlva a csík elkezd feltöltődni. Amíg ötödéig nem telik fel, a Shift semmit sem csinál.
- Séta közben nyomd meg a Q-t: egy kicsit előrelendülsz, és eltűnik a csík negyede. Nyomd meg azonnal még egyszer a Q-t, és semmi sem történik, amíg el nem telik egy másodperc. Ha a dash túl rövidnek vagy hosszúnak tűnik, változtasd meg a
DASH_SPEEDvagy aDASH_SECONDSértékét a MovementConfigban. - Ugorj, aztán a levegőben nyomd meg újra az ugrást a második ugráshoz. Érj földet, és próbáld újra: minden talajról indított ugrás visszaadja a levegőbeli ugrást.
- Tartsd nyomva a Space-t az egész ugrás alatt. Egy ugrásnak kell lennie, nem kettőnek, mert a levegőbeli ugráshoz új nyomás kell.
- Kapcsold be a Studio Device Simulatorát (e sorok írásakor béta: File, Beta Features, New Device Simulator, aztán indítsd újra a Studiót), vagy kapcsold be a régi Device Emulatort a Test menüben. Válassz egy telefont, és nyomd meg a Play gombot. Megjelennek a Sprint és a Dash gombok. Tartsd nyomva a Sprintet kormányzás közben, aztán tartsd nyomva az ugrógombot az egész ugrás alatt, és ellenőrizd, hogy csak egy ugrás van.
- Nyisd meg a Controller Emulatort (Controller az Emulation lapon, vagy Virtual controller a Device Simulator paneljén). Mozgás közben tartsd nyomva az L3-at a futáshoz, nyomd meg a B-t a dashhez, és kétszer az A-t a dupla ugráshoz.
- Állítsd vissza a karaktert a játék menüjéből. A csík újra teli, az Outputban nincs MovementCheck figyelmeztetés, és ha még mindig telefont szimulálsz, a Sprint és a Dash gombok a helyükön vannak.
- Most játssz csalóként. Nyomogasd a Client/Server kapcsolót, amíg az Explorer a klienst nem mutatja, jelöld ki a karaktered Humanoidját a Workspace-ben, és a Properties ablakban állítsd a WalkSpeed értékét 60-ra. Sétálj néhány másodpercig: az Outputban megjelenik egy ilyen figyelmeztetés:
MovementCheck: YourName moved 60 studs/s. Állítsd vissza 16-ra, aztán egy percig fuss és dashelj a szokásos módon, és ellenőrizd, hogy az Output hallgat. - Ha a place-edben a
Workspace.PlayerScriptsUseInputActionSystemértéke Enabled, teszteld újra a dupla ugrást: a Roblox dokumentációja nem mondja meg, hogy aJumpRequestvele is ugyanígy viselkedik-e.
Ha egyáltalán semmi sem történik, nyisd meg az Output ablakot a Studio Window menüjében, és keress piros hibát a MovementClienttől, vagy nézd meg a gyakori hibákat.
Milyen gyorsan és meddig: presetek játéktípus szerint
A jó futás a játéktól függ. Egy horroros üldözéshez rövid, lassú futás kell, amely a legrosszabb pillanatban ér véget; egy nagy nyílt pályához hosszú, hogy a játékosok ne unatkozzanak, amíg átkelnek rajta. Ezek a presetek ugyanazokat a scripteket használják, és csak a gyaloglási sebességet és a MovementConfigot változtatják. Ezek a mi kiindulópontjaink, a beállításokból számolva, nem játékosokon mérve.
| Játéktípus | CharacterWalkSpeed | SPRINT_BONUS (futási sebesség) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Teljes futás | Üresből telibe | Távolság egy csíkkal |
|---|---|---|---|---|---|---|---|
| Ez az útmutató | 16 | 10 (26) | 20 | 15 | 5 mp | 7,7 mp | 130 stud |
| Horroros üldözés | 12 | 8 (20) | 25 | 10 | 4 mp | 11 mp | 80 stud |
| Battlegroundok és harc | 16 | 12 (28) | 15 | 20 | 6,7 mp | 6 mp | körülbelül 187 stud |
| Nyílt világ vagy szimulátor | 16 | 16 (32) | 10 | 25 | 10 mp | 5 mp | 320 stud |
| Obby vagy parkour | 16 | 8 (24) | stamina nélkül: használd a ShiftToSprintet |
- A gyaloglási sebességet a StarterPlayerben állítod be. Jelöld ki a StarterPlayer elemet, és állítsd be a
CharacterWalkSpeedértékét (alapértelmezésben 16). Minden új karakter ezzel a sebességgel kezd, a futás ehhez adja hozzá aSPRINT_BONUSértéket, és a MovementCheck is ezt olvassa, így a szerveroldali ellenőrzés követi a választásodat. - A MovementCheck alkalmazkodik. A gyaloglási sebességet plusz a futási bónuszt plusz még egy negyedet enged meg a lagra: a horroros presetnél 25 stud/másodpercet, a nyílt világnál 40-et. Mást nem kell változtatni.
- Egy obbyban a futás megváltoztatja a pályát. Gyorsabb futással hosszabb szakadékokat lehet átugrani. Építsd meg az ugrásokat, aztán mindegyiket ellenőrizd futási sebességgel, különben a futás túl könnyűvé teszi a szakaszokat. Az obby checkpointokról szóló útmutató jól megy a ShiftToSprinttel.
- Egy horrorban a viszonyítási pont a gyilkos. Tedd az üldözőt kicsit gyorsabbá a gyaloglási sebességnél és kicsit lassabbá a futásnál, hogy a menekülés azon múljon, mikor fogy ki a csík. A horror játékról szóló útmutató végigveszi a ciklus többi részét.
Mi a baj a régi futás scriptekkel
A futásról, a dashről és a dupla ugrásról szóló régi útmutatók gyakran még működnek, de sokan olyan fogásokat használnak, amelyeket a Roblox azóta lecserélt, vagy elrontják a játékod más rendszereit. Ha egy lemásolt scriptet javítasz, vesd össze ezzel a listával.
| Fogás | Mi a probléma | Ez az útmutató |
|---|---|---|
BodyVelocity a dashhez | Elavult: a Roblox szerint helyette LinearVelocityt kell használni | LinearVelocity Plane módban |
Ciklus a RunService.RenderStepped eseményen | Új munkához a PreRender váltotta fel. A játéklogikának, például a staminának a Heartbeat a helye, amelyet a Roblox időszakos feladatokra ír le, mint az életerő visszatöltődése | Heartbeat deltaTime-mal |
Stamina ciklus wait() hívással | A wait() elavult a task.wait() javára, és fékezve fut, ezért tovább várhat a kértnél, és a waitenkénti fix fogyasztás egyenetlenül fogyasztja a staminát | Fogyás és visszatöltődés minden képkockában, a deltaTime figyelembevételével |
UserInputService.InputBegan chatellenőrzés nélkül | A Shift megnyomása chatüzenet írása közben elindítja a futást | ContextActionService, amely ráadásul gombot is ad a telefonhoz |
WalkSpeed = 16 elengedéskor vagy minden képkockában | Felülír minden más sebességet, például egy game pass bónuszát | A WalkSpeedet csak a futás elején és végén változtatja, az aktuális értékhez adva hozzá |
| Futás RemoteEventen keresztül, hogy a WalkSpeedet a szerver állítsa | Az exploiterek így is maguk állítják be a WalkSpeedjüket, a futás pedig a oda-vissza út miatt késéssel indul | Futás a kliensen, plusz távolságellenőrzés a szerveren |
Dupla ugrás minden JumpRequest-re | A JumpRequest egy ugráskérésre többször is elsül, a nyomva tartott gomb pedig tovább kérhet ugrásokat | 0,25 másodperces szünet és az új nyomás ellenőrzése |
UserInputService.TouchEnabled mint „ez telefon” ellenőrzés | Érintőképernyős laptopokon is true | A ContextActionService érintős eszközökön a saját eszközellenőrzésed nélkül tesz gombokat a képernyőre |
Humanoid:LoadAnimation a futásanimációhoz | Elavult az Animator:LoadAnimation javára | Az alábbi futásanimáció az Animatort használja |
A Roblox új módszere: Input Action System
A Roblox Input Action Systemről szóló oldala első példaként a karakter futását hozza. BindAction hívások helyett az irányítást a Studióban állítod be: egy CharacterSprint nevű InputAction egy input contexten belül a ReplicatedStorage-ban, egy InputBinding-gal a Left Shifthez, eggyel a kontroller Y gombjához, és eggyel, amely a StarterGui-ban megrajzolt képernyőgombhoz kapcsolódik. Ezután egy kliensscript figyeli a művelet Pressed és Released eseményét, lenyomáskor megduplázza a WalkSpeedet, elengedéskor pedig visszaállítja.
Akkor érdemes átállni rá, ha az irányítást a Studióban akarod elrendezni, nem kódban, ha saját érintőgombot szeretnél a ContextActionService gombja helyett, vagy olyan contexteket, amelyek egész irányításkészleteket cserélnek, például menükhöz vagy járművekhez. Az oldal azt is javasolja, hogy a Workspace.PlayerScriptsUseInputActionSystem értékét állítsd Enabledre, a server authority pedig meg is követeli ezt.
Az útmutató stamina ciklusa és dashe ugyanígy működik csak az Input Action Systemmel is (server authority nélkül). Tartsd meg a MovementConfigot, a Heartbeat ciklust és a dash() függvényt, töröld a két BindAction hívást és a kezelőiket, és helyettük kösd be a műveleteket: a futás műveletének Pressed eseménye a sprintHeld értékét true-ra állítja, a Released eseménye pedig false-ra, a dash műveletének Pressed eseménye pedig meghívja a dash() függvényt. Továbbra is minden képkockában keresd meg a Humanoidot, ahogy a MovementClient teszi, mert a dokumentáció példája az első karakter Humanoidját tárolja el, respawn után pedig az már nincs meg.
A Roblox a Character Controller Library-t is teszteli, egy bétát, amelyet a Studióban a Beta Features és az Avatar Settings alatt lehet bekapcsolni. A saját képességeiről szóló oldala példaként egy 0,2 másodperces aktív ablakkal és 1 másodperces visszatöltési idővel rendelkező dasht épít, vagyis ugyanazzal az időzítéssel, mint az útmutató dashe.
Hogyan bővítsd: animáció, kamera és futás pass
Futásanimáció
Készíts futásanimációt az Animation Editorban, adj neki Movement prioritást (a Roblox ezt ajánlja a gyaloglás- és futásanimációkhoz), publikáld, és másold ki az asset ID-ját. A MovementClientben hozz létre egy Animation-t ezzel az AnimationId-vel, töltsd be az Animator:LoadAnimation hívással a karakter Humanoidjában lévő Animator használatával, indítsd a tracket ott, ahol a futás kezdődik, és állítsd le ott, ahol véget ér. Minden új karakternél töltsd be újra.
Azokat az animációkat, amelyeket az eszközöd a karaktereden indít, mindenki látja, ha azt az Animatort használod, amelyet a Roblox odatett: a LocalScript által létrehozott Animatorra betöltött trackek nem replikálódnak. A Humanoid:LoadAnimation, amelyet sok régi útmutató használ, elavult.
Szélesebb kamera futás közben
Egy kicsit szélesebb látószög gyorsabbnak érezteti a futást. Ugyanazon a két helyen tweeneld a workspace.CurrentCamera.FieldOfView értékét az alapértelmezett 70-ről körülbelül 80-ra, amikor a futás elkezdődik, és vissza, amikor véget ér, például így: TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). A Roblox az értéket 1 és 120 közé korlátozza, és figyelmeztet, hogy a nagyon alacsony vagy nagyon magas értékek összezavarhatják a játékosokat. Ha a játékban egy másik script is változtatja a látószöget, a talált értékre tweenelj vissza, ne 70-re.
Gyors futás game passként
A game pass útmutató már működik ezzel a scripttel: a Speed bónusza a szerveren minden új karakternél 24-re állítja a WalkSpeedet, a MovementClient hozzáadja a futási bónuszt, a 34 stud/másodperc pedig belül marad azon, amit a MovementCheck megenged.
Egy olyan passhoz, amely magát a futást gyorsítja, add hozzá a FastSprint passt az abban az útmutatóban lévő PassConfig.ids táblához. A szerverscriptje ekkor beállítja a játékosnál az OwnsPass_FastSprint attribútumot, amint a vásárlás megerősítést nyer. A MovementClientben használj a Config.SPRINT_BONUS értéknél nagyobb bónuszt, ha player:GetAttribute("OwnsPass_FastSprint") == true. A MovementCheckben adj ezeknek a játékosoknak nagyobb tűréshatárt úgy, hogy ugyanezt az attribútumot a szerveren olvasod, ahol a játékos nem tudja megváltoztatni, és ellenőrizd, hogy az új maximális sebesség az alatt marad, amit az ellenőrzés jelez.
Egy korlát, amelyről érdemes tudni: ha egy másik script futás közben változtatja meg a WalkSpeedet, a futás vége a futás előtti sebességet állítja vissza. A következő respawn újra beállítja a pass sebességét, mert a game pass script minden új karakterre alkalmazza.
Gyakori hibák és megoldásaik
Nyisd meg az Output ablakot (Window menü, majd Output), mielőtt megnyomod a Play gombot. Ezeknél a scripteknél a legtöbb probléma ott hibát vagy figyelmeztetést ír ki a script nevével és a sor számával.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
A MovementClient vagy a MovementCheck egy olyan modulra vár, amely nincs meg pontosan ezen a néven. Egy MovementConfig nevű ModuleScriptnek kell lennie közvetlenül a ReplicatedStorage-ban. A script hibákról szóló útmutató részletesen tárgyalja ezt a figyelmeztetést.
A Shift semmit sem csinál
Ellenőrizd, hogy a ShiftToSprint vagy a MovementClient LocalScript legyen, ne Script, és hogy a StarterPlayerScriptsben legyen. A MovementClientnél a futás indításához a karakternek mozognia is kell, és legalább 20 staminával kell rendelkeznie, ezért mozgás közben tartsd nyomva a Shiftet. Ha futás helyett a Shift Lock kapcsol, lásd lent a Shift Lockról szóló kérdést.
A futás néhány másodperc után leáll
Ez a stamina kifogyása: 100 stamina másodpercenként 20-as fogyással 5 másodpercre elég. Növeld a MAX_STAMINA értékét, vagy csökkentsd a DRAIN_PER_SECOND értékét a MovementConfigban.
A dash semmit sem csinál
A dashhez 25 stamina kell, 1 másodpercet vár az előző után, és semmit sem csinál, amíg ülsz. Ha nem ez a gond, a karaktered gyökérpartján talán nincs RootAttachment nevű Attachment, ez egyes saját karaktereknél előfordul: add hozzá a StarterCharactered HumanoidRootPartjához.
A dupla ugrás nem sül el
A DoubleJumpnak LocalScriptnek kell lennie a StarterCharacterScripts alatt, nem a StarterPlayerScriptsben, mert a script.Parent értéket karakterként olvassa. A második ugrást a talaj elhagyása után nyomd meg: a nyomva tartott gomb nem számít új nyomásnak, a párkányról való lelépés pedig nem ad levegőbeli ugrást.
Telefonon nincs Sprint vagy Dash gomb
A ContextActionService csak érintős eszközökön adja hozzá a gombjait, ezért érintőképernyő nélküli PC-n soha nem látszanak. Telefonnal teszteld a Studio Device Simulatorában (ez béta: kapcsold be a New Device Simulatort a File, Beta Features alatt, és indítsd újra a Studiót). A BindAction legfeljebb 7 érintőgombot hozhat létre, ezért számold meg, hányat készítenek a játék más scriptjei.
A MovementCheck becsületes játékosokra panaszkodik
A szokásos okok: teleport egy másik szerverscriptből, futószalag vagy jármű, vagy lag. A saját teleportjaid után állítsd be a MovementCheckSkip attribútumot (lásd: Respawnok és teleportok), és növeld meg a SPEED_ALLOWANCE értékét, ha az ellenőrzés normál játék közben még mindig jelez.
A gyorsítás a futás után eltűnik
Egy másik script futás közben megváltoztatta a WalkSpeedet, a futás pedig a végén visszaállította azt a sebességet, amelyet az elején látott. A gyorsításokat a karakter spawnolásakor add, ahogy a game pass útmutató teszi, hogy a respawn újra a helyes sebességet állítsa be.
Elkészítés RoCode-dal
Ha nincs kedved mindezt kézzel beállítani, a RoCode megépítheti a nálad nyitott place-ben. A RoCode egy független AI-ügynök a Roblox Studióhoz, nem a Robloxtól: a webes chatben leírod a módosítást, a Studio pluginja pedig létrehozza a scripteket az Explorerben, így semmit sem kell beillesztened.
Adj hozzá Shiftre futást staminacsíkkal: gyaloglási sebesség plusz 10, amíg a Shift nyomva van, 100 stamina, másodpercenként 20 fogyás, másodpercenként 15 visszatöltődés egy másodperc pihenő után, Sprint gomb telefonokon, dash a Q-ra és dupla ugrás.
- Először átnézheti a place-edet a Search Scripts és a Read Script eszközzel, hogy megtalálja a WalkSpeedet módosító más scripteket (például egy game pass bónuszt), és a futás azokhoz adódjon hozzá
- A ModuleScriptet, a LocalScripteket és a szerveroldali ellenőrzést a Create Script eszközzel írja
- Az a feladata, hogy minden megírt script fordítását ellenőrizze a Check Scripttel, amely futtatás nélkül lefordítja a Studióban
- Minden módosításcsomag előtt és után visszavonási pontot tesz, így a Ctrl+Z egyszerre egy csomagot von vissza
A RoCode nem tud futásanimációt készíteni: hozd létre az Animation Editorban, és illeszd be az ID-ját. 3.9.11-es vagy újabb pluginnal a RoCode játéktesztet indíthat a Studióban, és irányíthat egy tesztkaraktert, hogy ellenőrizze, minden működik-e, 3.9.15-ös vagy újabb pluginnal pedig a tesztkarakter billentyűket is lenyomhat, például nyomva tarthatja a Shiftet, és ellenőrizheti, hogy a WalkSpeed nőtt-e. Maga dönti el, mikor indít játéktesztet, építésenként legfeljebb 2-t, plusz 1-et a saját javítása ellenőrzésére, és csak azt ellenőrzi, amit maga választott ki tesztelésre, ezért a futást, a dasht és a dupla ugrást próbáld ki te is, a telefonos gombokat pedig ellenőrizd a Studio Device Simulatorában. A mozgás egy rendszer a sok közül egy játékban; az egész játék elkészítése a RoCode-dal promptonként egy rendszerrel halad, ahogy itt. Hogyan csatlakozik a RoCode a Studióhoz.
Gyakori kérdések
Miért nem működik a futás script telefonon?
A telefonon nincs Shift billentyű. A futást a ContextActionService:BindAction hívással kösd be, és harmadik argumentumként adj át true-t: ez érintős eszközökön gombot tesz a képernyőre, ahogy a ShiftToSprint és a MovementClient is teszi.
A szerveren kell megcsinálni a futást?
Nem. Minden eszköz a saját karakterét mozgatja, ezért a szerver által beállított WalkSpeed nem állít meg egy csalót, aki beállíthatja a sajátját, az új sebesség pedig csak egy oda-vissza út után érkezik meg, így a futás késéssel indul. A futást a kliensen csináld, a szerveren pedig ellenőrizd, milyen messzire mozognak valójában a karakterek, ahogy az 5. lépésben. A Roblox server authority bétája másképp működik, és a mozgáskódot újra kell majd írni hozzá.
Miért fut tovább a karakter, amikor elengedtem a Shiftet?
A script lemaradt az elengedésről, általában azért, mert csak a lenyomást figyeli. A ContextActionService End-et küld, amikor a billentyűt elengedik, és Cancel-t, amikor egy másik kötés elveszi; a MovementClient mindkettőnél leáll, és akkor is, amikor kifogy a stamina, vagy a karakter megáll.
Hogyan adjak hozzá futásanimációt?
Töltsd be a futásanimációt a karakter Humanoidjában lévő Animator segítségével ugyanabban a LocalScriptben, indítsd el, amikor a futás kezdődik, és állítsd le, amikor véget ér. Adj neki Movement prioritást. A saját karaktereden indított animációkat mindenki látja.
Miért sül el magától a dupla ugrás telefonon?
A telefon nyomva tartott ugrógombja tovább kér ugrásokat. Csak akkor számíts egy ugrást újnak, ha a kérések egy pillanatra megszűntek, ahogy a DoubleJump script teszi.
Mennyi az alapértelmezett gyaloglási sebesség Robloxban?
16 stud/másodperc. A StarterPlayer.CharacterWalkSpeed értékéből jön, amely minden új karakter Humanoid.WalkSpeed értékét megadja. Az útmutató futása 10-et ad hozzá, így a futás 26.
Milyen gyors legyen a futás Robloxban?
A legtöbb játék a gyaloglási sebesség felét vagy egészét adja hozzá: a 16-ból 24 és 32 közötti érték lesz. A rövid, lassú futás a horrorhoz illik, a hosszú, gyors pedig a nagy pályákhoz. A játéktípus szerinti presetek mindegyikhez megadják a gyaloglási sebességet, a futási bónuszt és a stamina számait.
Hogyan készítsek futást staminával?
A stamina számát a játékos eszközén tárold, futás közben minden képkockában fogyaszd, rövid pihenő után töltsd vissza, mindkét esetben a képkocka idejével számolva, és állítsd le a futást, amikor eléri a 0-t. A 3. lépés MovementClientje ezt egy képernyőn lévő csíkkal csinálja; a számok a MovementConfigban vannak.
Hogyan fussak kontrollerrel Robloxban?
Kösd be a kontroller ButtonL3 gombját (a bal kar benyomása) a ContextActionService-szel a Left Shift mellé, ahogy itt mindkét script teszi. A ShiftToSprint az L3-at kapcsolóvá teszi, mert fárasztó benyomva tartani a kart, és közben kormányozni vele.
Ütközik a Shiftre futás a Shift Lockkal?
Ütközhet. Azok a játékosok, akik a Roblox beállításaiban bekapcsolták a Shift Lockot, a Shift billentyűvel kapcsolják, így egy billentyű két dolgot csinál. A Roblox dokumentációja szerint a Shift Lock API-kat kivezetik. Ha az ütközés zavarja a játékosaidat, kapcsold ki a StarterPlayer.EnableMouseLockOption beállítást, vagy a MovementClientben kösd a futást egy másik billentyűre, például a Left Ctrl-ra.
Források és további olvasnivaló
- Roblox Creator Docs: ContextActionService (angolul). BindAction, érintőgombok, a 7 gombos korlát, és miért jobb a legtöbb esetben az InputBeganél
- Roblox Creator Docs: Humanoid (angolul). WalkSpeed és a biztonsági megjegyzés, MoveDirection, StateChanged és ChangeState a dupla ugrás példájával
- Roblox Creator Docs: LinearVelocity (angolul). Plane mód, érintőtengelyek és MaxForce
- Roblox Creator Docs: Mover constraints (angolul). átállás az elavult BodyVelocityről a LinearVelocityre
- Roblox Creator Docs: UserInputService (angolul). JumpRequest, és miért kell neki debounce
- Roblox Creator Docs: Network ownership, movement validation, and physics (angolul). mit irányít a kliens, távolságellenőrzések, lyukas vödrök és kivételek a teleportokhoz
- Roblox Creator Docs: Server authority model (angolul). a szerveroldali mozgású modell, BindToSimulation és a hozzá szükséges Workspace beállítások
- Roblox Creator Docs: Input Action System (angolul). a Character Sprint példa InputActionnel és InputBindinggal
- Roblox Creator Docs: Custom abilities (angolul). dash képesség a Character Controller Libraryben
- Roblox Creator Docs: Studio testing modes (angolul). Device Simulator és Controller Emulator
Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.