Tutoriaali · Pelijärjestelmät

Miten tehdä juoksu Shiftillä Roblox Studiossa PC:lle, puhelimelle ja konsolille

Juoksu Shiftillä Robloxissa palautuu yhteen lukuun: Humanoidin WalkSpeed, joka kasvaa, kun Shift on pohjassa. Vaihe 1 tekee juuri tämän yhdessä lyhyessä LocalScriptissä, joka toimii sekä puhelimen Sprint-painikkeen että peliohjaimen kanssa. Oppaan loppuosa lisää sen, mitä isompi peli tarvitsee: kestävyyspalkin (stamina), modernin fysiikan syöksyn, tuplahypyn, joka ei laukea pohjassa pidetystä painikkeesta, ja ymmärryksen siitä, mitä palvelin voi tarkistaa ja mitä ei.

Päivitetty 20. marraskuuta 202620 min lukuaikaKirjoittaja:

Lyhyesti

Laita yksi LocalScript StarterPlayerScriptsiin, joka sitoo Sprint-toiminnon kutsulla ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Kun Shift on pohjassa, lisää 10 arvoon Humanoid.WalkSpeed (16:sta tulee 26), ja vapautettaessa palauta aiempi arvo. Argumentti true lisää kosketusnäytöille Sprint-painikkeen, ja tämän oppaan skriptissä tämä painike ja peliohjaimen L3 kytkevät juoksun päälle ja pois eivätkä toimi pitämällä.

  • Lisää nykyiseen WalkSpeediin äläkä aseta arvoa 26, jotta game passin nopeutus säilyy.
  • Juoksu toimii pelaajan laitteella. Palvelin ei voi pakottaa WalkSpeediä; se voi vain mitata, kuinka pitkälle hahmot liikkuvat, ja merkitä nopeuden, jota juoksu ei selitä.
  • Kestävyyspalkin, syöksyn ja tuplahypyn samalla idealla lisäävät vaiheet 2-4. Kuinka nopeasti ja kuinka pitkään juostaan, kertovat esiasetukset pelityypin mukaan, joissa on luvut kauhupelille, taistelulle ja avoimelle maailmalle.
Tällä sivulla
  1. Miten se toimii
  2. 1. Juoksu Shiftillä
  3. 2. Asetusmoduuli
  4. 3. Juoksu ja syöksy
  5. 4. Tuplahyppy
  6. 5. Palvelintarkistus
  7. 6. Testaus
  8. Nopeuden esiasetukset
  9. Vanhat skriptit
  10. Input Action System
  11. Laajennukset
  12. Common errors
  13. RoCodella
  14. Usein kysytyt kysymykset
  15. Lähteet ja lisälukemista

Miten juoksu toimii Robloxissa

HavainnollistusShift antaa juoksun WalkSpeedillä 26, kun palkki pienenee, Q tekee syöksyn neljänneksellä palkista, ja hypyn toinen painallus ilmassa hyppää vielä kerran.

Jokaisen pelaajan laite liikuttaa hänen omaa hahmoaan. Näppäimistö, ohjain tai kosketusnäyttö päättää, minne hahmo menee, ja Roblox välittää tuloksen palvelimelle ja kaikille muille. Siksi juoksu on LocalScript, joka nostaa Humanoid.WalkSpeed-arvoa, kun näppäin on pohjassa, ja se on kaikki, mitä vaihe 1 tekee. Oppaan loppuosa on se, mitä isompi peli tarvitsee sen ympärille: kestävyyspalkki, syöksy, tuplahyppy ja palvelintarkistus huijareille.

Mistä liikejärjestelmä koostuu
OsaMissä se onMitä se tekee
LocalScript ShiftToSprintStarterPlayerScriptsVaihe 1 sellaisenaan: juoksu näppäimistöllä, puhelimella ja peliohjaimella, ilman kestävyyttä. Kun lisäät kestävyyden ja syöksyn, MovementClient korvaa sen.
ModuleScript MovementConfigReplicatedStorageLuvut: juoksubonus, kestävyys ja syöksy. Sekä LocalScript että palvelintarkistus lukevat niitä.
LocalScript MovementClientStarterPlayerScriptsSitoo Sprintin ja Dashin näppäimeen, peliohjaimen painikkeeseen ja kosketuspainikkeeseen, pyörittää kestävyyssilmukkaa, piirtää palkin ja tekee syöksyn.
LocalScript DoubleJumpStarterCharacterScriptsAntaa yhden lisähypyn ilmassa. Uusi kopio käynnistyy jokaisessa uudessa hahmossa.
Script MovementCheckServerScriptServiceMittaa, kuinka pitkälle kukin hahmo oikeasti liikkuu, ja kirjoittaa varoituksen Outputiin, kun joku liikkuu pitkään nopeammin kuin juoksu ja syöksy sallivat.
Explorer, kun liikejärjestelmä on valmis
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Jos Scriptin ja LocalScriptin ero on sinulle uusi, Script, LocalScript ja ModuleScript selittää, missä kukin laji ajetaan ja miksi.

Vaihe 1: juoksu Shiftillä yhdessä LocalScriptissä

Jos tarvitset vain nopeamman juoksun Shiftin ollessa pohjassa, tämä yksi skripti riittää. Se antaa myös puhelimille Sprint-painikkeen näytölle ja peliohjaimella antaa juosta vasemmalla tikulla.

  1. Avaa Explorerissa StarterPlayer, vie osoitin StarterPlayerScriptsin päälle, paina +-painiketta ja lisää LocalScript nimeltä ShiftToSprint.
  2. Korvaa sen sisältö alla olevalla koodilla ja paina Play.
LocalScript kohteessa StarterPlayerScripts nimeltä ShiftToSprint
-- LocalScript kohteessa StarterPlayer > StarterPlayerScripts nimeltä ShiftToSprint.
-- Pidä Left Shiftiä pohjassa juostaksesi. Peliohjaimella paina vasenta tikkua (L3)
-- kytkeäksesi juoksun päälle tai pois. Puhelimella paina Sprint-painiketta kytkeäksesi sen päälle tai pois.

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

-- Asetukset
local SPRINT_BONUS = 10 -- lisätään WalkSpeediin juoksun aikana (16:sta tulee 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: painiketta on pidettävä pohjassa

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- WalkSpeed, johon palataan

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
		-- Muistetaan nykyinen nopeus ja lisätään siihen, jotta toisen skriptin nopeutus säilyy
		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
		-- Pito: juoksu niin kauan kuin näppäin tai painike on painettuna
		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
		-- Vaihto: jokainen painallus kytkee juoksun päälle tai pois
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Yksi kutsu sitoo näppäimen, peliohjaimen painikkeen ja kosketusnäytöillä näytön painikkeen
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- Uusi hahmo aloittaa kävellen: sen Humanoidilla on jo tavallinen WalkSpeed
player.CharacterAdded:Connect(function()
	sprinting = false
end)

Muuta SPRINT_BONUS-arvoa tehdäksesi juoksusta nopeamman tai hitaamman. Aseta TOGGLE_ON_TOUCH_AND_GAMEPAD arvoon false, jotta puhelimen painike ja L3 toimivat kuten Shift: juoksu vain pohjassa pidettäessä.

BindAction sitoo yhden toiminnon Left Shiftiin ja peliohjaimen L3-painikkeeseen, ja sen kolmas argumentti, true, lisää painikkeen kosketusnäytöille; SetTitle kirjoittaa siihen "Sprint". Käsittelijä saa myös itse syötteen, joten se erottaa näppäimistön painalluksen peliohjaimesta tai kosketuspainikkeesta. Kun juoksu alkaa, skripti muistaa nykyisen WalkSpeedin ja lisää SPRINT_BONUS-arvon; kun se päättyy, se palauttaa muistetun arvon. Toisen skriptin asettama nopeus, esimerkiksi game pass -oppaan Speed-etu, säilyy. Uusi hahmo aloittaa tavallisella WalkSpeedillä, joten CharacterAdded-käsittelijä vain nollaa lipun.

Pito vai vaihto?

Miten ShiftToSprint toimii kullakin laitteella, kun TOGGLE_ON_TOUCH_AND_GAMEPAD on true
Laite ja syöteToimii näinMiksi
Näppäimistö: Left ShiftPitoNäppäimen pitäminen liikkuessa on helppoa, ja vapautus pysäyttää juoksun heti.
Peliohjain: vasemman tikun painallus (L3)VaihtoTikun pitäminen painettuna ja sillä samalla ohjaaminen on väsyttävää.
Puhelin tai tabletti: Sprint-painike näytölläVaihtoPeukalo, joka pitää painiketta, ei voi samaan aikaan painaa Jumpia.

Testataksesi paina Play ja pidä Shiftiä pohjassa kävellessäsi: nopeus kasvaa 16:sta 26 studiin sekunnissa, ja kun vapautat, hidastut. Puhelinta varten valitse puhelin Studion Device Simulatorissa, paina Play ja paina Sprintiä kerran aloittaaksesi ja uudelleen lopettaaksesi. Peliohjainta varten avaa Controller Emulator pelitestin aikana ja paina L3:a. Täysi tarkistuslista laitteittain on vaiheessa 6.

Vaiheet 2 ja 3 korvaavat tämän skriptin toisella, jossa on kestävyyspalkki ja syöksy. Vaiheet 4 ja 5 lisäävät tuplahypyn ja palvelintarkistuksen ja toimivat kumman tahansa skriptin kanssa.

Vaihe 2: kestävyyden ja syöksyn luvut yhdessä moduulissa

Loppuvaa juoksua varten vaiheet 2 ja 3 vaihtavat ShiftToSprintin isompaan LocalScriptiin, jossa on kestävyyspalkki ja syöksy. Poista ensin ShiftToSprint: molemmat skriptit sitovat Sprint-toiminnon.

Kaikki luvut ovat yhdessä ModuleScriptissä, joten liikkeen tuntumaa säädetään yhdessä paikassa. MovementClient lukee niitä jokaisen pelaajan laitteella, ja MovementCheck lukee samaa moduulia palvelimella tietääkseen, millainen juoksun ja syöksyn nopeuden pitäisi olla.

  1. Vie Explorerissa osoitin ReplicatedStoragen päälle, paina +-painiketta ja lisää ModuleScript.
  2. Nimeä se MovementConfig ja korvaa sisältö alla olevalla koodilla.
ModuleScript kohteessa ReplicatedStorage nimeltä MovementConfig
-- Yksi lukujoukko liikkeen LocalScriptille ja palvelimen nopeustarkistukselle.

local MovementConfig = {
	SPRINT_BONUS = 10, -- lisätään nykyiseen WalkSpeediin: 16:sta (Robloxin oletusarvo) tulee 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 sekuntia juoksua täydestä palkista
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- sekunnit juoksun päättymisestä ennen kuin kestävyys alkaa palautua
	MIN_TO_START = 20, -- juoksun aloittamiseen tarvittava kestävyys, jotta tyhjä palkki ei vilku

	DASH_SPEED = 60, -- studia sekunnissa syöksyn aikana
	DASH_SECONDS = 0.2, -- näin syöksy kulkee noin 12 studia
	DASH_COST = 25, -- kestävyyttä
	DASH_COOLDOWN = 1,
}

return MovementConfig
Mitä kukin asetus tekee
AsetusArvoVaikutus
SPRINT_BONUS10Lisätään WalkSpeediin juoksun aikana. Robloxin oletus-WalkSpeed on 16, joten juoksu kulkee nopeudella 26 studia sekunnissa.
MAX_STAMINA100Täysi palkki.
DRAIN_PER_SECOND20Täysi palkki riittää 5 sekunnin juoksuun.
REGEN_PER_SECOND15Tyhjä palkki täyttyy noin 6.7 sekunnissa.
REGEN_DELAY1Lepoa sekunteina ennen palautumisen alkua.
MIN_TO_START20Juoksun aloittamiseen tarvittava kestävyys.
DASH_SPEED60Studia sekunnissa syöksyn aikana.
DASH_SECONDS0.2Kuinka kauan syöksy kestää: noin 12 studia 60 studin sekuntinopeudella.
DASH_COST25Kestävyyttä jokaista syöksyä kohden.
DASH_COOLDOWN1Sekuntia syöksyjen välillä.

Kumpikin puoli ajaa oman kopionsa moduulista (moduuli suoritetaan kerran kummallakin puolella), joten pelaaja, joka muuttaa näitä lukuja laitteellaan, muuttaa vain omaa kopiotaan. Mutta tässä se ei suojaa mitään: hänen laitteensa liikuttaa jo hänen hahmoaan, joten se voi antaa itselleen loputtoman kestävyyden riippumatta siitä, mitä moduulissa on. Vaiheen 5 palvelintarkistus on rakennettu tämä huomioiden.

Vaihe 3: juoksu kestävyydellä ja syöksy

Tämä LocalScript tekee sen, minkä pelaajat tuntevat. Se sitoo Sprintin ja Dashin, piirtää kestävyyspalkin, pyörittää kestävyyssilmukkaa joka ruutu ja tekee syöksyn.

  1. Avaa Explorerissa StarterPlayer, vie osoitin StarterPlayerScriptsin päälle ja lisää LocalScript nimeltä MovementClient.
  2. Korvaa sen sisältö alla olevalla koodilla.
LocalScript kohteessa StarterPlayerScripts nimeltä MovementClient
-- Pidä Shiftiä (tai L3:a tai puhelimen Sprint-painiketta) pohjassa juostaksesi, kun kestävyyttä on.
-- Paina Q:ta (tai B:tä tai Dash-painiketta) syöksyäksesi liikkeen suuntaan.

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

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

local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- WalkSpeed, johon palataan, kun juoksu päättyy
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Kestävyyspalkki: kehys täytöllä, jonka leveys vastaa jäljellä olevaa kestävyyttä
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

-- Juoksu: tässä vain lippu; alla oleva Heartbeat-silmukka päättää joka ruudulla, juostaanko
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Vain painallus ja vapautus muuttavat sitä: kosketuspainikkeella liukuva sormi lähettää Changen
	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()
	-- Istuessa ei syöksytä: istuva hahmo on hitsattu istuimeen, joten se työntäisi koko ajoneuvoa
	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 -- keskeytetään palautuminen, kuten juoksu tekee

	-- Syöksy sinne, minne pelaaja liikkuu, tai sinne, minne hän katsoo, jos hän seisoo paikallaan
	local direction = humanoid.MoveDirection
	if direction.Magnitude < 0.1 then
		direction = rootPart.CFrame.LookVector
	end
	direction = Vector3.new(direction.X, 0, direction.Z).Unit

	-- LinearVelocity Plane-tilassa pitää vaakanopeuden eikä häiritse painovoimaa
	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

-- Jokainen kutsu sitoo näppäimen, peliohjaimen painikkeen ja kosketuslaitteilla näytön painikkeen
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")

-- Joka ruutu: kulutetaan kestävyyttä juostessa ja liikkuessa, palautetaan lyhyen levon jälkeen
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

	-- Muutetaan WalkSpeediä vain juoksun alussa ja lopussa, jotta toisen skriptin
	-- asettama nopeus (esimerkiksi nopeuspassin) säilyy ja juoksu lisätään siihen
	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)

-- Uusi hahmo aloittaa täydellä kestävyydellä, eikä mitään ole painettuna
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- uusi Humanoid aloittaa tavallisella WalkSpeedillä
end)

Kestävyyspalkki luodaan koodissa asetuksella ResetOnSpawn false, joten se pysyy näytöllä uudelleensyntymisen jälkeen, ja alhaalla oleva CharacterAdded-käsittelijä täyttää sen uudelleen jokaiselle uudelle hahmolle. type Config -rivit kuvaavat, mitä moduuli palauttaa, jotta tiukka tyyppitarkistus huomaa kirjoitusvirheen asetuksen nimessä; pelin aikana ne eivät muuta mitään.

Näppäimistö, peliohjain ja puhelimen painike yhdellä kutsulla

ContextActionService:BindAction ottaa toiminnon nimen, käsittelijäfunktion, tiedon siitä, luodaanko kosketuspainike, ja sitten syötteet. Jos annat true kolmanneksi argumentiksi, ContextActionService lisää painikkeen näytölle kosketuslaitteilla, ScreenGuin ContextActionGui sisään pelaajan PlayerGuissa. SetTitle kirjoittaa näihin painikkeisiin "Sprint" ja "Dash". BindAction voi luoda enintään 7 kosketuspainiketta, joten seuraa määrää, jos pelisi muutkin skriptit käyttävät niitä.

Käsittelijä saa syötteen tilan: Begin painettaessa ja End vapautettaessa. onSprint vain muistaa, onko Sprint pohjassa. Se laskee vapautukseksi myös Cancelin, jonka ContextActionService lähettää, kun toinen sidonta kaappaa syötteen, ja ohittaa Changen, jonka kosketuspainikkeella liikkuva sormi voi lähettää. Molemmat käsittelijät palauttavat Pass, joten saman näppäimen seuraava sidonta saa myös syötteen.

Robloxin ContextActionService-viite suosittelee sitä UserInputService.InputBegan-tapahtuman sijaan useimmissa tapauksissa. Sen esimerkki: auton äänitorvi H:ssa, joka ei saa soida, kun pelaaja kirjoittaa chattiin. Sidonta laukeaa vain niin kauan kuin se on tämän syötteen viimeisin, joten kun chat ottaa näppäimistön, sinun ei tarvitse tarkistaa mitään. Peliohjaimen syötteet: ButtonL3 (vasemman tikun painallus, sitä pidetään liikkuessa) ja ButtonB. Robloxin omassa juoksuesimerkissä käytetään ButtonY-painiketta, joten vaihda BindActionin KeyCode, jos se sopii peliisi paremmin.

Kestävyyssilmukka

RunService.Heartbeat laukeaa joka ruutu fysiikka-askeleen jälkeen ja välittää deltaTime-arvon, sekuntien määrän edellisestä ruudusta. Jos kulutus- ja palautumisnopeus kerrotaan sillä, täysi palkki riittää 5 sekuntiin, pyöriikö peli 30 vai 240 ruudun sekuntinopeudella.

Joka ruutu silmukka päättää, pitääkö hahmon juosta: Sprint on pohjassa, hahmo kävelee (Humanoid.MoveDirection on nollavektori, kun hahmo seisoo) ja kestävyyttä on vielä. Juoksun aloittamiseen tarvitaan vähintään MIN_TO_START (20); jatkamiseen riittää mikä tahansa yli 0. Ilman tätä väliä tyhjä palkki, joka täyttyy joka ruutu hiukan, kytkisi juoksun päälle ja pois joka ruutu. Palautuminen alkaa REGEN_DELAY-ajan (1 sekunti) kuluttua viimeisestä juoksusta tai syöksystä, joten palkin tyhjennettyään pelaaja odottaa noin 2.3 sekuntia ennen kuin voi taas juosta.

WalkSpeed muuttuu vain sinä ruutuna, jona juoksu alkaa tai päättyy. Alussa skripti muistaa nykyisen WalkSpeedin ja lisää SPRINT_BONUS-arvon; lopussa se palauttaa muistetun arvon. Siksi toisen skriptin asettama nopeus säilyy: game pass -oppaan Speed-etu asettaa WalkSpeedin 24:ään, ja tällä skriptillä sen omistajat juoksevat nopeudella 34. Skripti, joka kirjoittaa WalkSpeed = 16 joka ruutu tai jokaisella vapautuksella, kumoaisi tämän edun huomaamatta.

Syöksy

Syöksy työntää hahmoa sinne, minne hän liikkuu, tai sinne, minne hän katsoo, jos hän seisoo paikallaan, ja suunta tasataan niin, ettei se koskaan osoita ylös tai alas. Se maksaa 25 kestävyyttä, keskeyttää palautumisen kuten juoksu ja sillä on 1 sekunnin jäähtymisaika. Maata siinä ei tarkisteta, joten se toimii myös ilmassa, mikä sopii hyvin yhteen tuplahypyn kanssa. Kun hahmo istuu, syöksy ei tee mitään: istuva hahmo on hitsattu istuimeen, ja ajoneuvossa työntö voisi siirtää koko ajoneuvoa.

Työntö on LinearVelocity-rajoite juuripartin RootAttachmentissa. Plane-tilassa X- ja Z-akseleilla se pitää vaakanopeuden 60 studissa sekunnissa eikä koske pystysuuntaan, joten painovoima toimii ja syöksy kielekkeeltä putoaa normaalisti. MaxForce on math.huge, joten mikään ei rajoita työntöä. Debris:AddItem tuhoaa rajoitteen DASH_SECONDS-ajan kuluttua pakottamatta skriptiä odottamaan, joten syöksy kestää 0.2 sekuntia, noin 12 studia tällä nopeudella.

Vanhat tutoriaalit käyttävät BodyVelocity-objektia, jonka Roblox on merkinnyt vanhentuneeksi ja kehottanut käyttämään sen sijaan LinearVelocitya. Sen kikan, jossa MaxForce on nolla yhdellä akselilla, korvaavat LinearVelocityn Line-, Plane- ja Vector-tilat. Koska pelaajan laite simuloi itse hahmoaan, LocalScriptin luoma rajoite liikuttaa sitä, ja muut pelaajat näkevät syöksyn kuten minkä tahansa muun liikkeen.

Robloxin oma UI-tutoriaali kiinnittää rajoitteen kohteeseen humanoid.RootPart.RootAttachment täsmälleen samalla tavalla. Jos pelissäsi on oma hahmo, jonka juuripartissa ei ole Attachmentia nimeltä RootAttachment, syöksy ei tee mitään: lisää se StarterCharacterisi HumanoidRootPartiin.

Vaihe 4: tuplahyppy

Tuplahyppy asuu omassa LocalScriptissään StarterCharacterScriptsissä. Roblox laittaa kopion tämän säiliön skripteistä jokaiseen hahmoon syntymisen yhteydessä, eivätkä nämä kopiot säily uudelleensyntymisen yli, joten jokainen elämä alkaa tuoreella skriptillä, eikä mitään siirry edellisestä.

  1. Avaa Explorerissa StarterPlayer, vie osoitin StarterCharacterScriptsin päälle ja lisää LocalScript nimeltä DoubleJump.
  2. Korvaa sen sisältö alla olevalla koodilla.
LocalScript kohteessa StarterCharacterScripts nimeltä DoubleJump
-- Antaa yhden lisähypyn ilmassa. Käynnistyy uudelleen jokaiselle uudelle hahmolle,
-- joten uudelleensyntymisen jälkeen mitään ei siirry mukana.

local UserInputService = game:GetService("UserInputService")

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

local EXTRA_JUMPS = 1
local MIN_SECONDS_BETWEEN_JUMPS = 0.25 -- JumpRequest laukeaa useita kertoja yhdestä painalluksesta
local NEW_PRESS_GAP = 0.1 -- pohjassa pidetty hyppypainike lähettää JumpRequestia jatkuvasti; näin pitkä tauko tarkoittaa, että se vapautettiin

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
		-- Hyppy maasta (ei yksi omista ilmahypyistämme) palauttaa ilmahypyt
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- JumpRequest laukeaa, kun pelaaja pyytää hyppyä, esimerkiksi Spacella tai puhelimen hyppypainikkeella
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Vain uusi painallus hyppää uudelleen, jotta pohjassa pidetty painike ei kuluta ilmahyppyä
	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)

Aseta EXTRA_JUMPS arvoon 2 kolmoishyppyä varten.

Skripti seuraa hahmon tilaa Humanoid.StateChanged-tapahtumalla. Siirtymä tilaan Jumping, joka ei tullut tilasta Freefall, on hyppy maasta, joten se antaa ilmahypyn, ja Landed ottaa sen taas pois. Jos astut kielekkeeltä, hahmo päätyy Freefalliin ilman hyppyä, joten se ei saa ilmahyppyä. Jos haluat sen myös silloin, aseta jumpsLeft myös siirryttäessä Freefalliin mistä tahansa tilasta paitsi Jumpingista.

UserInputService.JumpRequest laukeaa, kun pelaaja pyytää hyppyä, esimerkiksi Spacella tai puhelimen hyppypainikkeella. Robloxin viite varoittaa, että se laukeaa useita kertoja yhdestä hyppypyynnöstä, ja neuvoo debouncea, joten skripti ohittaa pyynnöt 0.25 sekunnin ajan viimeisestä hypystä. Pohjassa pidetty hyppypainike voi myös jatkaa hyppyjen pyytämistä ja kuluttaisi ilmahypyn samalla hetkellä, kun hahmo irtoaa maasta, joten pyyntö lasketaan uudeksi painallukseksi vasta 0.1 sekunnin pyynnöttömän tauon jälkeen.

Itse ilmahyppy on Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Robloxin viitteen mukaan sitä on kutsuttava LocalScriptistä laitteella, jolla on hahmon verkko-omistajuus, ja oletuksena se on pelaajan oma laite eikä palvelin. Viitteen ChangeState-koodiesimerkki on juuri tuplahyppy.

Vaihe 5: speedhackin kiinnisaaminen palvelimella

Juoksututoriaalit pysähtyvät usein asiakkaaseen. Palvelimen Script ei voi luottaa pelaajan WalkSpeediin, koska huijarit muuttavat sitä laitteellaan, mutta se näkee, mihin heidän hahmonsa päätyy. MovementCheck mittaa tämän kahdesti sekunnissa ja kirjoittaa varoituksen Outputiin, kun joku liikkuu pitkään nopeammin kuin juoksu ja syöksy sallivat. Juoksun ja syöksyn luvut se lukee MovementConfigista, joten lisää tämä moduuli vaiheesta 2, vaikka jättäisit ShiftToSprintin.

  1. Vie osoitin ServerScriptServicen päälle ja lisää Script nimeltä MovementCheck.
  2. Korvaa sen sisältö alla olevalla koodilla.
Script kohteessa ServerScriptService nimeltä MovementCheck
-- Pelaajien laitteet liikuttavat omia hahmojaan, joten huijari voi asettaa minkä tahansa WalkSpeedin.
-- Tämä tarkistus mittaa, kuinka pitkälle kukin hahmo oikeasti liikkuu, ja kirjoittaa Outputiin,
-- kun joku liikkuu pitkään nopeammin kuin juoksu ja syöksy sallivat. Se vain varoittaa:
-- viive, teleportit ja liukuhihnat voivat näyttää ylinopeudelta, joten säädä se ennen kuin rangaiset ketään.

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 -- sekuntia
-- Juoksunopeus plus vara viiveelle. Suurenna, jos myyt nopeutuksia.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- vara yhdelle tai kahdelle syöksylle
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- kuinka nopeasti aiemmat syöksyt annetaan anteeksi

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- juuripart, jolla lastPosition mitattiin
local excess: { [Player]: number } = {} -- studit sallitun yli, annetaan vähitellen anteeksi

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
			-- Uudelleensyntyminen on uusi juuripart, ja palvelimen teleportti (kierroksen alku, checkpoint)
			-- asettaa alla olevan attribuutin: aloitetaan mittaus alusta eikä merkitä hyppäystä
			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
				-- Vain vaakaliike: nopea putoaminen ei ole huijaamista
				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

Varoitus näkyy Studion Outputissa. Julkaistussa pelissä se päätyy Developer Consolen palvelinlokiin, jota voit lukea pelin omistajana: katso tuloste julkaistussa pelissä.

Mitä se mittaa

Puolen sekunnin välein skripti lukee jokaisen hahmon juuripartin sijainnin ja mittaa, kuinka paljon se on siirtynyt vaakasuunnassa edellisestä tarkistuksesta. Korkeus ohitetaan, joten putoamisia ja hyppyjä ei koskaan lasketa; Robloxin neuvo liikkeen tarkistamisesta ehdottaa samaa projektiota XZ-tasolle peleihin, joissa kävellään maassa. Sallittu raja on oletuskävelynopeus plus juoksubonus ja vielä neljännes viiveen varalle: 32.5 studia sekunnissa. Tämän ylittävä matka menee "vuotavaan ämpäriin" (leaky bucket), kertymään, josta Robloxin dokumentaatiossa sanotaan, että se sopii monille kehittäjille hyvin lyhyisiin pyrähdyksiin. Ämpäristä vuotaa 3 studia joka tarkistuksella, ja skripti varoittaa, kun siinä on yli 24 studia, mikä on vara noin kahdelle syöksylle.

Mitä tarkistus saa kiinni sen lukujen perusteella laskettuna
HuijariMitä MovementCheck tekee
Asettaa WalkSpeedin 100:aanVaroittaa noin sekunnin juoksun jälkeen
Asettaa WalkSpeedin 50:eenVaroittaa noin 2.5 sekunnin juoksun jälkeen
Syöksyy peräkkäin ilman jäähtymisaikaa (60 studia sekunnissa)Varoittaa noin 1.5 sekunnin jälkeen
Teleporttaa yli 43 studia kerrallaVaroittaa seuraavalla tarkistuksella
Juoksee enintään 38 studin sekuntinopeudella, noin puolitoista kertaa juoksua nopeamminEi mitään: alle 38.5 studin sekuntinopeudella ämpäri tyhjenee yhtä nopeasti kuin täyttyy
Muuttaa MovementConfigiaan loputtoman kestävyyden vuoksiEi mitään: juoksu 26 studin sekuntinopeudella on sallittu kuinka pitkään tahansa
Lentää, hyppii rajattomasti tai kulkee seinien läpiEi mitään: tarkistus ohittaa korkeuden eikä katso törmäyksiä

Tarkistus siis saa kiinni karkeat huijaukset, joissa pelaaja on huomattavasti kaikkia muita nopeampi, ja päästää hienovaraiset läpi. Tämä on etäisyyteen perustuvan tarkistuksen rehellinen raja ja syy siihen, että Roblox tekee jotain vahvempaa (katso server authority alempana).

Miksi se vain varoittaa

Robloxin dokumentaatiossa todetaan, että yksinkertaiset nopeustarkistukset voivat merkitä rehellisiä pelaajia, joiden yhteys on epävakaa, ja hajoavat peleissä, joissa on ajoneuvoja tai muuta monimutkaista liikettä. Viivepiikit, liukuhihnat, ajoneuvot, hahmoja sinkoavat räjähdykset ja omat teleporttisi voivat näyttää ylinopeudelta, joten skripti vain tulostaa varoituksen. Seuraa Outputia, kun sinä ja testaajasi pelaatte normaalisti, suurenna SPEED_ALLOWANCE-arvoa, jos rehelliset pelaajat kompastuvat siihen, ja lisää rangaistus, esimerkiksi pelaajan palauttaminen taaksepäin, vasta kun tarkistus on hiljaa normaalissa pelissä. Jos pelissäsi räjähdykset sinkoavat hahmoja, ohita myös pelaajat, joiden Humanoidilla ei ole terveyttä jäljellä.

Uudelleensyntymiset ja teleportit

Uudelleensyntyminen luo uuden juuripartin, ja skripti aloittaa mittauksen alusta, kun se näkee sen, joten kuolema kaukana syntymäpisteestä ei koskaan lasketa ylinopeudeksi. Omien palvelinskriptiesi tekemät teleportit tarvitsevat poikkeuksen, kuten Robloxin dokumentaatiossa sanotaan mille tahansa pelille, jossa on teleportteja. Lisää teleportin jälkeen player:SetAttribute("MovementCheckSkip", true), ja seuraava tarkistus alkaa mitata uudesta sijainnista eikä merkitse hyppäystä:

Teleporttioppaan padit ja valikot sekä ensimmäisen pelin oppaan Finish-pad asettavat sen jo jokaisen siirron jälkeen.

Vain palvelimelta tuleva arvo lasketaan. Attribuutti, jonka pelaaja asettaa laitteellaan, jää tälle laitteelle (katso mikä replikoituu ja mikä ei), joten huijari ei voi kytkeä tarkistusta pois sillä.

Ratkaisu tulevaisuuteen: server authority

Robloxin turvallisuusdokumentaatio kutsuu server authority -mallia, kirjoitushetkellä betassa, luotettavimmaksi tavaksi pysäyttää liikehuijaukset. Totuuden lähteeksi tulee palvelin, ja pelaajien laitteet vain ilmoittavat syötteensä, mikä dokumentaation mukaan estää speedhackien toiminnan, koska laitteeseen ei koskaan luoteta oman sijaintinsa ilmoittamisessa.

Siirtyminen on uudelleenkirjoitus eikä säätö. Tässä mallissa palvelin laskee liikkeen, joten vain LocalScriptin asettama WalkSpeed tai LinearVelocity kumoutuu, kun tila tulee palvelimelta. Robloxin dokumentaatiossa sanotaan, että päälogiikan on toimittava RunService:BindToSimulation()-funktioissa ModuleScriptissä, jota sekä asiakas että palvelin ajavat. Malli tarvitsee myös useita Workspace-asetuksia, mukaan lukien PlayerScriptsUseInputActionSystem, joten myös ohjauksesi siirtyy Input Action Systemiin. Pidä tämän oppaan versio, kunnes olet siirtänyt juoksun, kestävyyden ja syöksyn tähän malliin. Siihen asti tämänkaltainen etäisyystarkistus on juuri sitä, mitä Robloxin liikkeen tarkistusta koskeva osio kuvaa.

Vaihe 6: testaa jokaisella laitteella

  1. Paina Play ja pidä Shiftiä pohjassa kävellessäsi. Nopeus kasvaa 16:sta 26 studiin sekunnissa, ja vihreä palkki näytön alareunassa pienenee. Noin 5 sekunnin jälkeen se on tyhjä, ja kävelet taas.
  2. Vapauta Shift. Sekunnin kuluttua palkki alkaa täyttyä. Kunnes se on täyttynyt viidesosaan, Shift ei tee mitään.
  3. Paina Q kävellessäsi: syöksähdät hieman eteenpäin, ja neljännes palkista on poissa. Paina Q heti uudelleen, eikä mitään tapahdu ennen kuin sekunti on kulunut. Jos syöksy tuntuu liian lyhyeltä tai pitkältä, muuta DASH_SPEED- tai DASH_SECONDS-arvoa MovementConfigissa.
  4. Hyppää ja paina sitten hyppyä uudelleen ilmassa toista hyppyä varten. Laskeudu ja kokeile uudelleen: jokainen hyppy maasta palauttaa ilmahypyn.
  5. Pidä Spacea pohjassa koko hypyn ajan. Tuloksen pitäisi olla yksi hyppy eikä kaksi, koska ilmahyppy tarvitsee uuden painalluksen.
  6. Kytke Studion Device Simulator päälle (kirjoitushetkellä se on beta: File, Beta Features, New Device Simulator, käynnistä sitten Studio uudelleen) tai kytke vanha Device Emulator päälle Test-valikosta. Valitse puhelin ja paina Play. Sprint- ja Dash-painikkeet ilmestyvät. Pidä Sprintiä ohjatessasi, pidä sitten hyppypainiketta koko hypyn ajan ja tarkista, että hyppyjä on vain yksi.
  7. Avaa Controller Emulator (Controller Emulation-välilehdellä tai Virtual controller Device Simulatorin paneelissa). Pidä L3 pohjassa liikkuessasi juostaksesi, paina B syöksyyn ja A kahdesti tuplahyppyyn.
  8. Nollaa hahmo pelin valikosta. Palkki on taas täysi, Outputissa ei ole MovementCheck-varoitusta, ja jos simuloit yhä puhelinta, Sprint- ja Dash-painikkeet ovat paikallaan.
  9. Pelaa nyt huijarina. Paina Client/Server-kytkintä, kunnes Explorer näyttää asiakkaan, valitse hahmosi Humanoid Workspacessa ja aseta WalkSpeed arvoon 60 Properties-ikkunassa. Kävele muutama sekunti: Outputiin ilmestyy varoitus, kuten MovementCheck: YourName moved 60 studs/s. Palauta 16, juokse ja syöksy sitten minuutin ajan normaalisti ja tarkista, että Output on hiljaa.
  10. Jos paikassasi Workspace.PlayerScriptsUseInputActionSystem on Enabled, testaa tuplahyppy uudelleen: Robloxin dokumentaatio ei kerro, käyttäytyykö JumpRequest sen kanssa samoin.

Jos mitään ei tapahdu lainkaan, avaa Output-ikkuna Studion Window-valikosta ja etsi punaista virhettä MovementClientiltä tai katso yleiset virheet.

Kuinka nopeasti ja kuinka pitkään: esiasetukset pelityypin mukaan

Oikea juoksu riippuu pelistä. Kauhupelin takaa-ajo tarvitsee lyhyen hitaan juoksun, joka loppuu pahimmalla hetkellä; iso avoin kartta tarvitsee pitkän, jotta pelaajilla ei ole tylsää sen ylittämisessä. Nämä esiasetukset käyttävät samoja skriptejä ja muuttavat vain kävelynopeutta ja MovementConfigia. Ne ovat lähtökohtiamme, laskettu asetuksista eikä mitattu pelaajilla.

Kävelynopeus, juoksu ja kestävyys pelityypin mukaan. Juoksuaika on MAX_STAMINA / DRAIN_PER_SECOND; palautuminen on MAX_STAMINA / REGEN_PER_SECOND plus 1 sekunnin REGEN_DELAY
PelityyppiCharacterWalkSpeedSPRINT_BONUS (juoksunopeus)DRAIN_PER_SECONDREGEN_PER_SECONDTäysi juoksuTyhjästä täyteenMatka yhdellä palkilla
Tämä opas1610 (26)20155 s7.7 s130 studia
Kauhupelin takaa-ajo128 (20)25104 s11 s80 studia
Battlegroundit ja taistelu1612 (28)15206.7 s6 snoin 187 studia
Avoin maailma tai simulaattori1616 (32)102510 s5 s320 studia
Obby tai parkour168 (24)ei kestävyyttä: käytä ShiftToSprintiä
  • Kävelynopeus asetetaan StarterPlayerissa. Valitse StarterPlayer ja aseta CharacterWalkSpeed (oletus 16). Jokainen uusi hahmo aloittaa tällä nopeudella, juoksu lisää siihen SPRINT_BONUS-arvon, ja MovementCheck lukee myös sen, joten palvelintarkistus seuraa valintaasi.
  • MovementCheck mukautuu. Se sallii kävelynopeuden plus juoksubonuksen ja vielä neljänneksen viiveen varalle: 25 studia sekunnissa kauhupelin esiasetukselle, 40 avoimelle maailmalle. Muuta ei tarvitse muuttaa.
  • Obbyssa juoksu muuttaa radan. Nopeammalla juoksulla ylitetään pidempiä kuiluja. Rakenna hypyt ja testaa sitten jokainen juoksunopeudella, muuten juoksu tekee vaiheista liian helppoja. Obbyn checkpoint-opas sopii hyvin yhteen ShiftToSprintin kanssa.
  • Kauhupelissä mittapuu on tappaja. Tee takaa-ajajasta hieman kävelyä nopeampi ja hieman juoksua hitaampi, jotta pakeneminen riippuu siitä, milloin palkki loppuu. Kauhupelin opas käy läpi muun silmukan.

Mikä vanhoissa juoksuskripteissä on vialla

Vanhat juoksun, syöksyn ja tuplahypyn tutoriaalit toimivat usein yhä, mutta monet käyttävät tapoja, jotka Roblox on sittemmin korvannut, tai rikkovat pelisi muita järjestelmiä. Jos korjaat kopioitua skriptiä, vertaa sitä tähän listaan.

Tapoja vanhoista tutoriaaleista ja mitä tämä opas tekee niiden sijaan
TapaMikä on ongelmaTämä opas
BodyVelocity syöksyynVanhentunut: Roblox kehottaa käyttämään sen sijaan LinearVelocityaLinearVelocity Plane-tilassa
Silmukka RunService.RenderStepped-tapahtumassaUudessa työssä sen on korvannut PreRender. Pelilogiikan, kuten kestävyyden, paikka on Heartbeat, jonka Roblox kuvaa jaksollisille tehtäville, kuten terveyden palautumiselleHeartbeat deltaTimella
Kestävyyssilmukka wait()-funktiollawait() on vanhentunut task.wait()-funktion hyväksi ja sitä hidastetaan, joten se voi odottaa pyydettyä pidempään, ja kiinteä kulutus jokaista waitia kohden kuluttaa kestävyyttä epätasaisestiKulutus ja palautuminen joka ruutu deltaTime huomioiden
UserInputService.InputBegan ilman chat-tarkistustaShiftin painallus chat-viestiä kirjoitettaessa käynnistää juoksunContextActionService, joka lisäksi lisää puhelimelle painikkeen
WalkSpeed = 16 vapautettaessa tai joka ruutuKirjoittaa minkä tahansa muun nopeuden päälle, esimerkiksi game passin edunMuuttaa WalkSpeediä vain juoksun alussa ja lopussa lisäten nykyiseen arvoon
Juoksu RemoteEventin kautta, jotta palvelin asettaa WalkSpeedinHuijarit asettavat WalkSpeedinsä silti itse, ja juoksu alkaa edestakaisen matkan viiveelläJuoksu asiakkaalla plus etäisyystarkistus palvelimella
Tuplahyppy jokaisella JumpRequestillaJumpRequest laukeaa useita kertoja yhdestä hyppypyynnöstä, ja pohjassa pidetty painike voi jatkaa hyppyjen pyytämistä0.25 sekunnin tauko ja uuden painalluksen tarkistus
UserInputService.TouchEnabled "onko tämä puhelin" -tarkistuksenaSe on true kosketusnäytöllisissä kannettavissaContextActionService lisää painikkeet näytölle kosketuslaitteilla ilman omaa laitetarkistustasi
Humanoid:LoadAnimation juoksuanimaatiolleVanhentunut Animator:LoadAnimation-kutsun hyväksiAlla oleva juoksuanimaatio käyttää Animatoria

Robloxin uusi tapa: Input Action System

Robloxin Input Action System -sivu ottaa hahmon juoksun ensimmäiseksi esimerkiksi. BindAction-kutsujen sijaan ohjaus määritetään Studiossa: InputAction nimeltä CharacterSprint input contextin sisällä ReplicatedStoragessa, yksi InputBinding Left Shiftille, yksi peliohjaimen Y-painikkeelle ja yksi, joka on yhdistetty StarterGuissa piirtämääsi näytön painikkeeseen. Sitten asiakasskripti kuuntelee toiminnon Pressed- ja Released-tapahtumia, tuplaa WalkSpeedin painettaessa ja palauttaa sen vapautettaessa.

Siihen kannattaa siirtyä, jos haluat järjestää ohjauksen Studiossa etkä koodissa, oman kosketuspainikkeen ContextActionServicen painikkeen sijaan tai kontekstit, jotka vaihtavat kokonaisia ohjausjoukkoja, esimerkiksi valikoille tai ajoneuvoille. Sivu neuvoo myös asettamaan Workspace.PlayerScriptsUseInputActionSystem arvoon Enabled, ja server authority vaatii sen.

Tämän oppaan kestävyyssilmukka ja syöksy toimivat samoin pelkän Input Action Systemin kanssa (ilman server authorityä). Pidä MovementConfig, Heartbeat-silmukka ja dash(), poista kaksi BindAction-kutsua ja niiden käsittelijät ja kytke niiden tilalle toiminnot: juoksutoiminnon Pressed asettaa sprintHeld-arvon trueksi ja sen Released falseksi, ja syöksytoiminnon Pressed kutsuu dash()-funktiota. Jatka Humanoidin etsimistä joka ruutu, kuten MovementClient tekee, koska dokumentaation esimerkki tallentaa ensimmäisen hahmon Humanoidin, ja uudelleensyntymisen jälkeen sitä ei enää ole.

Roblox testaa myös Character Controller Library -kirjastoa, betaa, joka kytketään päälle Studion Beta Featuresissa ja Avatar Settingsissä. Sen omia kykyjä käsittelevä sivu rakentaa esimerkkinä syöksyn, jossa on 0.2 sekunnin aktiivinen ikkuna ja 1 sekunnin jäähtymisaika, eli sama ajoitus kuin tämän oppaan syöksyllä.

Miten laajentaa: animaatio, kamera ja juoksupassi

Juoksuanimaatio

Tee juoksuanimaatio Animation Editorissa, anna sille prioriteetti Movement (Roblox suosittelee sitä kävely- ja juoksuanimaatioille), julkaise se ja kopioi assetin ID. Luo MovementClientissä Animation tällä AnimationId-arvolla, lataa se Animator:LoadAnimation-kutsulla käyttäen hahmon Humanoidin sisällä olevaa Animatoria, käynnistä raita siinä kohdassa, jossa juoksu alkaa, ja pysäytä se siinä, jossa se päättyy. Lataa se uudelleen jokaiselle uudelle hahmolle.

Animaatiot, joita laitteesi ajaa hahmollasi, näkyvät kaikille, jos käytät Animatoria, jonka Roblox on sinne laittanut: LocalScriptin luomaan Animatoriin ladatut raidat eivät replikoidu. Humanoid:LoadAnimation, jota monet vanhat tutoriaalit käyttävät, on vanhentunut.

Laajempi kamera juoksun aikana

Hieman laajempi näkökenttä saa juoksun tuntumaan nopeammalta. Tweenaa samoissa kahdessa kohdassa workspace.CurrentCamera.FieldOfView oletusarvosta 70 noin 80:een, kun juoksu alkaa, ja takaisin, kun se päättyy, esimerkiksi kutsulla TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox rajoittaa arvon välille 1-120 ja varoittaa, että hyvin pienet tai hyvin suuret arvot voivat hämmentää pelaajia. Jos jokin muu pelisi skripti muuttaa näkökenttää, tweenaa takaisin löytämääsi arvoon äläkä 70:een.

Nopea juoksu game passina

Game pass -opas toimii jo tämän skriptin kanssa: sen Speed-etu asettaa palvelimella WalkSpeedin 24:ään jokaiselle uudelle hahmolle, MovementClient lisää päälle juoksubonuksen, ja 34 studia sekunnissa pysyy MovementCheckin sallimissa rajoissa.

Passia varten, joka nopeuttaa itse juoksua, lisää FastSprint-passi kyseisen oppaan PassConfig.ids-tauluun. Sen palvelinskripti asettaa silloin pelaajalle attribuutin OwnsPass_FastSprint heti, kun osto on vahvistettu. Käytä MovementClientissä arvoa Config.SPRINT_BONUS suurempaa bonusta, kun player:GetAttribute("OwnsPass_FastSprint") == true. Anna MovementCheckissä näille pelaajille suurempi sallittu raja lukemalla sama attribuutti palvelimella, jossa pelaaja ei voi muuttaa sitä, ja tarkista, että uusi enimmäisnopeus pysyy alle sen, minkä tarkistus merkitsee.

Yksi rajoitus, joka kannattaa tietää: jos toinen skripti muuttaa WalkSpeediä kesken juoksun, juoksun loppu palauttaa nopeuden, joka oli ennen sitä. Seuraava uudelleensyntyminen asettaa passin nopeuden taas, koska game pass -skripti soveltaa sitä jokaiseen uuteen hahmoon.

Yleiset virheet ja ratkaisut

Avaa Output-ikkuna (Window-valikko, sitten Output) ennen kuin painat Play. Useimmat näiden skriptien ongelmat tulostavat sinne virheen tai varoituksen, jossa on skriptin nimi ja rivinumero.

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

MovementClient tai MovementCheck odottaa moduulia, jota ei ole täsmälleen tällä nimellä. Sen on oltava ModuleScript nimeltä MovementConfig suoraan ReplicatedStoragen sisällä. Skriptivirheiden opas käy tämän varoituksen läpi tarkemmin.

Shift ei tee mitään

Tarkista, että ShiftToSprint tai MovementClient on LocalScript eikä Script ja että se on StarterPlayerScriptsissä. MovementClientin kanssa hahmon on lisäksi käveltävä ja sillä on oltava vähintään 20 kestävyyttä juoksun aloittamiseksi, joten pidä Shiftiä pohjassa liikkuessasi. Jos juoksun sijaan Shift Lock vaihtuu, katso alla oleva Shift Lock -kysymys.

Juoksu loppuu muutaman sekunnin jälkeen

Kestävyys loppuu: 100 kestävyyttä 20:n sekuntikulutuksella riittää 5 sekuntiin. Suurenna MAX_STAMINA-arvoa tai pienennä DRAIN_PER_SECOND-arvoa MovementConfigissa.

Syöksy ei tee mitään

Syöksy tarvitsee 25 kestävyyttä, odottaa 1 sekunnin edellisen jälkeen eikä tee mitään, kun istut. Jos syy ei ole tämä, hahmosi juuripartissa ei ehkä ole Attachmentia nimeltä RootAttachment, mikä on mahdollista joillain omilla hahmoilla: lisää se StarterCharacterisi HumanoidRootPartiin.

Tuplahyppy ei laukea

DoubleJumpin on oltava LocalScript StarterCharacterScriptsissä eikä StarterPlayerScriptsissä, koska se lukee script.Parent-arvon hahmona. Paina hyppyä toisen kerran maasta irtoamisen jälkeen: pohjassa pidettyä painiketta ei lasketa uudeksi painallukseksi, eikä kielekkeeltä astuminen anna ilmahyppyä.

Puhelimessa ei ole Sprint- tai Dash-painiketta

ContextActionService lisää painikkeensa vain kosketuslaitteille, joten PC:llä ilman kosketusnäyttöä niitä ei koskaan näy. Testaa puhelimella Studion Device Simulatorissa (se on beta: kytke New Device Simulator päälle kohdassa File, Beta Features ja käynnistä Studio uudelleen). BindAction voi luoda enintään 7 kosketuspainiketta, joten laske, montako pelisi muut skriptit tekevät.

MovementCheck valittaa rehellisistä pelaajista

Tavalliset syyt: teleportti toisesta palvelinskriptistä, liukuhihna tai ajoneuvo tai viive. Aseta MovementCheckSkip-attribuutti omien teleporttiesi jälkeen (katso Uudelleensyntymiset ja teleportit) ja suurenna SPEED_ALLOWANCE-arvoa, jos tarkistus laukeaa yhä normaalissa pelissä.

Nopeutus katoaa juoksun jälkeen

Toinen skripti muutti WalkSpeediä juoksun aikana, ja juoksu palautti päättyessään nopeuden, jonka se näki alussa. Anna nopeutukset hahmon syntyessä, kuten game pass -opas tekee, jotta uudelleensyntyminen asettaa taas oikean nopeuden.

Tee se RoCodella

Jos et halua määrittää tätä kaikkea käsin, RoCode voi koota sen paikkaan, joka sinulla on auki. RoCode on itsenäinen tekoälyagentti Roblox Studioon, ei Robloxin tekemä: kuvailet muutoksen verkkochatissa, ja sen Studio-lisäosa luo skriptit Exploreriisi, joten koodia ei tarvitse liittää.

Sinä kirjoitat

Lisää juoksu Shiftillä kestävyyspalkilla: kävelynopeus plus 10, kun Shift on pohjassa, 100 kestävyyttä, kulutus 20 sekunnissa, palautuminen 15 sekunnissa sekunnin levon jälkeen, Sprint-painike puhelimille, syöksy Q:lla ja tuplahyppy.

RoCode tekee
  • Voi ensin käydä paikkasi läpi Search Scriptsillä ja Read Scriptillä löytääkseen muut skriptit, jotka muuttavat WalkSpeediä (esimerkiksi game passin edun), jotta juoksu lisätään niihin
  • Kirjoittaa ModuleScriptin, LocalScriptit ja palvelintarkistuksen Create Scriptillä
  • Sitä on ohjeistettu tarkistamaan jokaisen kirjoitetun skriptin kääntyminen Check Scriptillä, joka kääntää sen Studiossa ajamatta
  • Asettaa kumouspisteen ennen jokaista muutoserää ja sen jälkeen, joten Ctrl+Z peruu yhden erän kerrallaan

RoCode ei osaa tehdä juoksuanimaatiota: luo se Animation Editorissa ja liitä sen ID. Lisäosalla 3.9.11 tai uudemmalla RoCode voi käynnistää pelisi pelitestin Studiossa ja ohjata testihahmoa tarkistaakseen, että kaikki toimii, ja lisäosalla 3.9.15 tai uudemmalla testihahmo voi painaa näppäimiä, esimerkiksi pitää Shiftiä pohjassa ja tarkistaa, että WalkSpeed kasvoi. Se päättää itse, milloin pelitesti ajetaan, enintään 2 rakennusta kohden sekä 1 korjauksensa tarkistamiseen, ja tarkistaa vain sen, minkä se itse päätti testata, joten kokeile juoksua, syöksyä ja tuplahyppyä itse ja tarkista puhelimen painikkeet Studion Device Simulatorissa. Liike on yksi järjestelmä monista pelissä; kokonaisen pelin luominen RoCodella etenee yksi järjestelmä kehotetta kohden, kuten tässä. Miten RoCode yhdistyy Studioon.

Usein kysytyt kysymykset

Miksi juoksuskripti ei toimi puhelimella?

Puhelimessa ei ole Shift-näppäintä. Sido juoksu ContextActionService:BindAction-kutsulla ja anna true kolmanneksi argumentiksi: se lisää painikkeen näytölle kosketuslaitteilla, kuten sekä ShiftToSprint että MovementClient tekevät.

Pitääkö juoksu tehdä palvelimella?

Ei. Jokainen laite liikuttaa omaa hahmoaan, joten palvelimen asettama WalkSpeed ei pysäytä huijaria, joka voi asettaa omansa, ja uusi nopeus tulee vasta edestakaisen matkan jälkeen, joten juoksu alkaa viiveellä. Tee juoksu asiakkaalla ja tarkista palvelimella, kuinka pitkälle hahmot oikeasti liikkuvat, kuten vaiheessa 5. Robloxin server authority -beta toimii toisin, ja liikekoodi on kirjoitettava sitä varten uudelleen.

Miksi hahmo jatkaa juoksua, kun vapautin Shiftin?

Skripti ohitti vapautuksen, yleensä koska se kuuntelee vain painallusta. ContextActionService lähettää End, kun näppäin vapautetaan, ja Cancel, kun toinen sidonta kaappaa sen; MovementClient pysähtyy molemmissa sekä silloin, kun kestävyys loppuu tai hahmo lakkaa liikkumasta.

Miten lisätä juoksuanimaatio?

Lataa juoksuanimaatio hahmon Humanoidissa olevan Animatorin kautta samassa LocalScriptissä, käynnistä se, kun juoksu alkaa, ja pysäytä, kun se päättyy. Anna sille prioriteetti Movement. Omalla hahmollasi käynnistetyt animaatiot näkyvät kaikille.

Miksi tuplahyppy laukeaa puhelimella itsestään?

Pohjassa pidetty puhelimen hyppypainike jatkaa hyppyjen pyytämistä. Laske hyppy uudeksi vain, jos pyynnöt ovat hetkeksi lakanneet, kuten DoubleJump-skripti tekee.

Mikä on Robloxin oletuskävelynopeus?

16 studia sekunnissa. Se tulee asetuksesta StarterPlayer.CharacterWalkSpeed, joka asettaa jokaisen uuden hahmon Humanoid.WalkSpeed-arvon. Tämän oppaan juoksu lisää 10, joten juoksu kulkee nopeudella 26.

Kuinka nopea juoksun pitäisi olla Robloxissa?

Useimmat pelit lisäävät puolikkaasta kokonaiseen kävelynopeuden: 16:sta tulee jotain 24:n ja 32:n väliltä. Lyhyt hidas juoksu sopii kauhupeliin ja pitkä nopea isoihin karttoihin. Esiasetukset pelityypin mukaan antavat kullekin kävelynopeuden, juoksubonuksen ja kestävyyden luvut.

Miten tehdä juoksu kestävyydellä?

Säilytä kestävyyslukua pelaajan laitteella, kuluta sitä joka ruutu juoksun aikana ja palauta lyhyen levon jälkeen, molemmat ruudun aika huomioiden, ja pysäytä juoksu, kun luku on 0. Vaiheen 3 MovementClient tekee tämän näytön palkin kanssa; luvut ovat MovementConfigissa.

Miten juostaan ohjaimella Robloxissa?

Sido peliohjaimen ButtonL3 (vasemman tikun painallus) ContextActionServicen kautta yhdessä Left Shiftin kanssa, kuten molemmat tämän oppaan skriptit tekevät. ShiftToSprint tekee L3:sta vaihtokytkimen, koska tikun pitäminen painettuna ja sillä samalla ohjaaminen on väsyttävää.

Onko juoksu Shiftillä ristiriidassa Shift Lockin kanssa?

Voi olla. Pelaajat, jotka ovat kytkeneet Shift Lockin päälle Robloxin asetuksista, vaihtavat sitä Shift-näppäimellä, joten yksi näppäin tekee kahta asiaa. Robloxin dokumentaatiossa sanotaan, että Shift Lockin API:t poistuvat käytöstä. Jos ristiriita haittaa pelaajiasi, kytke StarterPlayer.EnableMouseLockOption pois päältä tai sido juoksu MovementClientissä toiseen näppäimeen, esimerkiksi Left Ctrliin.

Lähteet ja lisälukemista

Miten koodi tarkistettiin: jokainen tämän sivun skripti läpäisee Luaun tiukan tyyppitarkistuksen Roblox API:n määrittelyillä (luau-lsp, 20. marraskuuta 2026). Tyyppitarkistus löytää virheet API-nimissä ja väärät tyypit, mutta ei pelilogiikan virheitä, joten testaa kaikki Studiossa ennen julkaisua.

Kokeile RoCodea omassa pelissäsi.

Ilmaisia krediittejä joka päivä, ei korttia. Asenna lisäosa, kuvaile ominaisuus ja katso, mitä Studioon ilmestyi.