Útmutató · Játékrendszerek

Hogyan készíts Shiftre futást (sprintet) a Roblox Studióban PC-re, telefonra és konzolra

A Shiftre futás Robloxban egyetlen számon múlik: a Humanoid WalkSpeed értékén, amely nő, amíg a Shift nyomva van. Az 1. lépés pontosan ezt csinálja egy rövid LocalScriptben, amely a telefon Sprint gombjával és a kontrollerrel is működik. Az útmutató többi része azt adja hozzá, amire egy nagy játéknak szüksége van: staminacsíkot, modern fizikára épülő dasht, dupla ugrást, amely nem sül el a nyomva tartott gombtól, és annak megértését, mit tud ellenőrizni a szerver, és mit nem.

Frissítve 2026. november 20.25 perc olvasásSzerző:

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
  1. Hogyan működik
  2. 1. Futás Shiftre
  3. 2. Beállítási modul
  4. 3. Futás és dash
  5. 4. Dupla ugrás
  6. 5. Szerveroldali ellenőrzés
  7. 6. Teszt
  8. Sebességpresetek
  9. Régi scriptek
  10. Input Action System
  11. Bővítések
  12. Common errors
  13. RoCode-dal
  14. Gyakori kérdések
  15. Források és további olvasnivaló

Hogyan működik a futás Robloxban

IllusztrációA Shift 26-os WalkSpeeddel futtat, miközben a csík fogy, a Q a csík negyedéért dasht csinál, a levegőben megnyomott második ugrás pedig még egyet ugrik.

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.

Miből áll a mozgásrendszer
ElemHol vanMit csinál
LocalScript ShiftToSprintStarterPlayerScriptsAz 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 MovementConfigReplicatedStorageSzámok: futási bónusz, stamina és dash. A LocalScript és a szerveroldali ellenőrzés is olvassa őket.
LocalScript MovementClientStarterPlayerScriptsA 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 DoubleJumpStarterCharacterScriptsEgy extra ugrást ad a levegőben. Minden új karakterben egy új példány indul.
Script MovementCheckServerScriptServiceMé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.
Az Explorer, amikor a mozgásrendszer kész
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.

  1. Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterPlayerScripts fölé, nyomd meg a + gombot, és szúrj be egy LocalScriptet ShiftToSprint néven.
  2. Cseréld le a tartalmát az alábbi kódra, és nyomd meg a Play gombot.
LocalScript helye: StarterPlayerScripts neve: ShiftToSprint
-- 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ó?

Hogyan működik a ShiftToSprint az egyes eszközökön, ha a TOGGLE_ON_TOUCH_AND_GAMEPAD értéke true
Eszköz és bemenetÍgy működikMiért
Billentyűzet: Left ShiftNyomva tartásMozgá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őnKapcsoló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.

  1. Az Explorerben vidd az egeret a ReplicatedStorage fölé, nyomd meg a + gombot, és szúrj be egy ModuleScriptet.
  2. Nevezd át erre: MovementConfig, és cseréld le a tartalmát az alábbi kódra.
ModuleScript helye: ReplicatedStorage neve: MovementConfig
-- 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
Mit csinál az egyes beállítás
BeállításÉrtékHatás
SPRINT_BONUS10Futás közben hozzáadódik a WalkSpeedhez. A Roblox alapértelmezett WalkSpeedje 16, ezért a futás 26 stud/másodperc.
MAX_STAMINA100Teli csík.
DRAIN_PER_SECOND20Egy teli csík 5 másodperc futásra elég.
REGEN_PER_SECOND15Az üres csík nagyjából 6,7 másodperc alatt telik fel.
REGEN_DELAY1Pihenő másodpercek a visszatöltődés kezdete előtt.
MIN_TO_START20A futás indításához szükséges stamina.
DASH_SPEED60Stud/másodperc a dash alatt.
DASH_SECONDS0.2Meddig tart a dash: körülbelül 12 stud 60 stud/másodpercnél.
DASH_COST25Stamina minden dashért.
DASH_COOLDOWN1Má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.

  1. Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterPlayerScripts fölé, és szúrj be egy LocalScriptet MovementClient néven.
  2. Cseréld le a tartalmát az alábbi kódra.
LocalScript helye: StarterPlayerScripts neve: MovementClient
-- 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.

  1. Az Explorerben nyisd ki a StarterPlayer elemet, vidd az egeret a StarterCharacterScripts fölé, és szúrj be egy LocalScriptet DoubleJump néven.
  2. Cseréld le a tartalmát az alábbi kódra.
LocalScript helye: StarterCharacterScripts neve: DoubleJump
-- 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.

  1. Vidd az egeret a ServerScriptService fölé, és szúrj be egy Scriptet MovementCheck néven.
  2. Cseréld le a tartalmát az alábbi kódra.
Script helye: ServerScriptService neve: MovementCheck
-- 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.

Mit kap el az ellenőrzés, ha a saját számaival számolunk
CsalóMit csinál a MovementCheck
100-ra állítja a WalkSpeedetNagyjából egy másodperc futás után figyelmeztet
50-re állítja a WalkSpeedetNagyjá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álA következő ellenőrzéskor figyelmeztet
Legfeljebb 38 stud/másodperccel fut, nagyjából másfélszer gyorsabban a futásnálSemmit: 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áhozSemmit: a 26 stud/másodperces futás akármeddig megengedett
Repül, korlátlanul ugrál vagy átmegy a falakonSemmit: 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 a startRound fü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

  1. 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.
  2. 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.
  3. 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_SPEED vagy a DASH_SECONDS értékét a MovementConfigban.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. Á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.
  9. 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.
  10. 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 a JumpRequest vele 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.

Gyaloglási sebesség, futás és stamina játéktípus szerint. A futás ideje MAX_STAMINA / DRAIN_PER_SECOND; a visszatöltődés MAX_STAMINA / REGEN_PER_SECOND plusz 1 másodperc REGEN_DELAY
JátéktípusCharacterWalkSpeedSPRINT_BONUS (futási sebesség)DRAIN_PER_SECONDREGEN_PER_SECONDTeljes futásÜresből telibeTávolság egy csíkkal
Ez az útmutató1610 (26)20155 mp7,7 mp130 stud
Horroros üldözés128 (20)25104 mp11 mp80 stud
Battlegroundok és harc1612 (28)15206,7 mp6 mpkörülbelül 187 stud
Nyílt világ vagy szimulátor1616 (32)102510 mp5 mp320 stud
Obby vagy parkour168 (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á a SPRINT_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ások régi útmutatókból, és mit csinál helyettük ez az útmutató
FogásMi a problémaEz az útmutató
BodyVelocity a dashhezElavult: a Roblox szerint helyette LinearVelocityt kell használniLinearVelocity 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éseHeartbeat deltaTime-mal
Stamina ciklus wait() hívássalA 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átFogyás és visszatöltődés minden képkockában, a deltaTime figyelembevételével
UserInputService.InputBegan chatellenőrzés nélkülA Shift megnyomása chatüzenet írása közben elindítja a futástContextActionService, amely ráadásul gombot is ad a telefonhoz
WalkSpeed = 16 elengedéskor vagy minden képkockábanFelülír minden más sebességet, például egy game pass bónuszátA 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ítsaAz exploiterek így is maguk állítják be a WalkSpeedjüket, a futás pedig a oda-vissza út miatt késéssel indulFutás a kliensen, plusz távolságellenőrzés a szerveren
Dupla ugrás minden JumpRequest-reA JumpRequest egy ugráskérésre többször is elsül, a nyomva tartott gomb pedig tovább kérhet ugrásokat0,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 trueA 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óhozElavult az Animator:LoadAnimation javáraAz 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.

Te írod

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.

A RoCode elvégzi
  • 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ó

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.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.