Tutorial · Συστήματα παιχνιδιού

Πώς να φτιάξεις sprint με Shift στο Roblox Studio για PC, κινητό και κονσόλα

Το sprint με Shift στο Roblox καταλήγει σε έναν αριθμό: το WalkSpeed του Humanoid, που ανεβαίνει όσο είναι πατημένο το Shift. Το Βήμα 1 κάνει ακριβώς αυτό σε ένα σύντομο LocalScript, που δουλεύει και με το κουμπί Sprint στο κινητό και με gamepad. Ο υπόλοιπος οδηγός προσθέτει ό,τι χρειάζεται ένα μεγάλο παιχνίδι: μπάρα stamina, dash με τη σύγχρονη φυσική, διπλό άλμα που δεν ενεργοποιείται από πατημένο κουμπί, και κατανόηση του τι μπορεί να ελέγξει ο server και τι όχι.

Ενημερώθηκε 20 Νοεμβρίου 202628 λεπτά ανάγνωσηςΣυντάκτης:

Με λίγα λόγια

Βάλτε ένα LocalScript στο StarterPlayerScripts που δένει την ενέργεια Sprint μέσω ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3). Όσο το Shift είναι πατημένο, προσθέτετε 10 στο Humanoid.WalkSpeed (το 16 γίνεται 26), και όταν αφήνεται επαναφέρετε την προηγούμενη τιμή. Το όρισμα true προσθέτει κουμπί Sprint στις οθόνες αφής, και στο script αυτού του οδηγού αυτό το κουμπί και το L3 του gamepad ανοίγουν και κλείνουν το sprint, αντί να δουλεύουν με κράτημα.

  • Προσθέτετε στο τρέχον WalkSpeed αντί να βάζετε 26, ώστε να διατηρείται η επιτάχυνση από ένα game pass.
  • Το sprint δουλεύει στη συσκευή του παίκτη. Ο server δεν μπορεί να επιβάλει WalkSpeed· μπορεί μόνο να μετρά πόσο μακριά κινούνται οι χαρακτήρες και να επισημαίνει ταχύτητα που δεν εξηγείται από το sprint.
  • Μπάρα stamina, dash και διπλό άλμα πάνω στην ίδια ιδέα προσθέτουν τα Βήματα 2 έως 4. Πόσο γρήγορα και για πόσο να τρέχει κανείς σας λένε τα presets ανά είδος παιχνιδιού, με αριθμούς για τρόμου, μάχης και ανοιχτού κόσμου.
Σε αυτή τη σελίδα
  1. Πώς δουλεύει
  2. 1. Sprint με Shift
  3. 2. Module ρυθμίσεων
  4. 3. Sprint και dash
  5. 4. Διπλό άλμα
  6. 5. Έλεγχος στον server
  7. 6. Δοκιμή
  8. Presets ταχύτητας
  9. Παλιά scripts
  10. Input Action System
  11. Επεκτάσεις
  12. Common errors
  13. Με το RoCode
  14. Συχνές ερωτήσεις
  15. Πηγές και περαιτέρω ανάγνωση

Πώς δουλεύει το sprint στο Roblox

ΕικονογράφησηΤο Shift δίνει sprint με WalkSpeed 26 ενώ η μπάρα αδειάζει, το Q κάνει dash για ένα τέταρτο της μπάρας, και ένα δεύτερο πάτημα άλματος στον αέρα πηδά ξανά.

Η συσκευή κάθε παίκτη κινεί τον δικό του χαρακτήρα. Το πληκτρολόγιο, το χειριστήριο ή η οθόνη αφής αποφασίζουν πού πηγαίνει ο χαρακτήρας, και το Roblox μεταφέρει το αποτέλεσμα στον server και σε όλους τους άλλους. Γι' αυτό το sprint είναι ένα LocalScript που ανεβάζει το Humanoid.WalkSpeed όσο είναι πατημένο το πλήκτρο, και αυτό είναι όλο όσα κάνει το Βήμα 1. Ο υπόλοιπος οδηγός είναι ό,τι χρειάζεται ένα μεγάλο παιχνίδι γύρω από αυτό: μπάρα stamina, dash, διπλό άλμα και έλεγχος στον server για cheaters.

Από τι αποτελείται το σύστημα κίνησης
ΣτοιχείοΠού βρίσκεταιΤι κάνει
LocalScript ShiftToSprintStarterPlayerScriptsΤο Βήμα 1 από μόνο του: sprint σε πληκτρολόγιο, κινητό και gamepad, χωρίς stamina. Όταν προσθέτετε stamina και dash, το αντικαθιστά το MovementClient.
ModuleScript MovementConfigReplicatedStorageΟι αριθμοί: μπόνους sprint, stamina και dash. Τους διαβάζουν και το LocalScript και ο έλεγχος στον server.
LocalScript MovementClientStarterPlayerScriptsΔένει τα Sprint και Dash σε πλήκτρο, κουμπί gamepad και κουμπί αφής, τρέχει τον βρόχο stamina, σχεδιάζει τη μπάρα και κάνει το dash.
LocalScript DoubleJumpStarterCharacterScriptsΔίνει ένα επιπλέον άλμα στον αέρα. Ένα νέο αντίγραφο ξεκινά σε κάθε νέο χαρακτήρα.
Script MovementCheckServerScriptServiceΜετρά πόσο μακριά κινείται πραγματικά κάθε χαρακτήρας και γράφει προειδοποίηση στο Output όταν κάποιος κινείται για πολύ πιο γρήγορα από όσο επιτρέπουν το sprint και το dash.
Ο Explorer όταν το σύστημα κίνησης είναι έτοιμο
ReplicatedStorage
  MovementConfig ModuleScript new
ServerScriptService
  MovementCheck Script new
StarterPlayer
  StarterCharacterScripts
    DoubleJump LocalScript new
  StarterPlayerScripts
    MovementClient LocalScript new

Αν η διαφορά ανάμεσα σε Script και LocalScript είναι καινούργια για εσάς, το Script, LocalScript και ModuleScript εξηγεί πού εκτελείται το καθένα και γιατί.

Βήμα 1: sprint με Shift σε ένα LocalScript

Αν χρειάζεστε μόνο πιο γρήγορο τρέξιμο όσο είναι πατημένο το Shift, αρκεί μόνο αυτό το script. Δίνει επίσης στα κινητά ένα κουμπί Sprint στην οθόνη, και στο gamepad σας αφήνει να τρέχετε με τον αριστερό μοχλό.

  1. Στον Explorer αναπτύξτε το StarterPlayer, περάστε τον κέρσορα πάνω από το StarterPlayerScripts, πατήστε το κουμπί + και εισάγετε ένα LocalScript με όνομα ShiftToSprint.
  2. Αντικαταστήστε το περιεχόμενό του με τον κώδικα παρακάτω και πατήστε Play.
LocalScript στο StarterPlayerScripts με όνομα ShiftToSprint
-- LocalScript στο StarterPlayer > StarterPlayerScripts με όνομα ShiftToSprint.
-- Κρατήστε πατημένο το Left Shift για να τρέξετε. Στο gamepad πατήστε τον αριστερό μοχλό (L3) για να
-- ανοίξετε ή να κλείσετε το sprint. Στο κινητό πατήστε το κουμπί Sprint για να το ανοίξετε ή να το κλείσετε.

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

-- Ρυθμίσεις
local SPRINT_BONUS = 10 -- προστίθεται στο WalkSpeed κατά το sprint (το 16 γίνεται 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: το κουμπί πρέπει να μένει πατημένο

local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- το WalkSpeed στο οποίο πρέπει να επιστρέψουμε

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

local function setSprinting(on: boolean)
	local humanoid = getHumanoid()
	if not humanoid or on == sprinting then
		return
	end
	sprinting = on
	if on then
		-- Θυμόμαστε την τρέχουσα ταχύτητα και προσθέτουμε σε αυτήν, ώστε να μένει η επιτάχυνση από άλλο script
		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
		-- Κράτημα: sprint όσο το πλήκτρο ή το κουμπί είναι πατημένο
		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
		-- Εναλλαγή: κάθε πάτημα ανοίγει ή κλείνει το sprint
		setSprinting(not sprinting)
	end
	return Enum.ContextActionResult.Pass
end

-- Μία κλήση δένει το πλήκτρο, το κουμπί του gamepad και, σε οθόνες αφής, ένα κουμπί στην οθόνη
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")

-- Ένας νέος χαρακτήρας ξεκινά περπατώντας: το Humanoid του έχει ήδη το κανονικό WalkSpeed
player.CharacterAdded:Connect(function()
	sprinting = false
end)

Αλλάξτε το SPRINT_BONUS για πιο γρήγορο ή πιο αργό sprint. Βάλτε το TOGGLE_ON_TOUCH_AND_GAMEPAD σε false για να δουλεύουν το κουμπί του κινητού και το L3 όπως το Shift: sprint μόνο όσο είναι πατημένα.

Το BindAction δένει μία ενέργεια στο Left Shift και στο κουμπί L3 του gamepad, και το τρίτο του όρισμα, true, προσθέτει κουμπί στις οθόνες αφής· το SetTitle γράφει πάνω του "Sprint". Ο handler παίρνει και την ίδια την είσοδο, οπότε ξεχωρίζει ένα πάτημα στο πληκτρολόγιο από gamepad ή κουμπί αφής. Όταν ξεκινά το sprint, το script θυμάται το τρέχον WalkSpeed και προσθέτει SPRINT_BONUS· όταν τελειώνει, επαναφέρει την τιμή που θυμήθηκε. Μια ταχύτητα που όρισε άλλο script, για παράδειγμα το perk Speed από τον οδηγό για τα game passes, διατηρείται. Ένας νέος χαρακτήρας ξεκινά με το κανονικό WalkSpeed, οπότε ο handler του CharacterAdded απλώς μηδενίζει τη σημαία.

Κράτημα ή εναλλαγή;

Πώς δουλεύει το ShiftToSprint σε κάθε συσκευή όταν το TOGGLE_ON_TOUCH_AND_GAMEPAD είναι true
Συσκευή και είσοδοςΔουλεύει ωςΓιατί
Πληκτρολόγιο: Left ShiftΚράτημαΕίναι εύκολο να κρατάτε το πλήκτρο ενώ κινείστε, και αν το αφήσετε το sprint σταματά αμέσως.
Gamepad: πάτημα του αριστερού μοχλού (L3)ΕναλλαγήΤο να κρατάτε τον μοχλό πατημένο και ταυτόχρονα να στρίβετε με αυτόν είναι κουραστικό.
Κινητό ή tablet: κουμπί Sprint στην οθόνηΕναλλαγήΟ αντίχειρας που κρατά το κουμπί δεν μπορεί την ίδια στιγμή να πατήσει Jump.

Για να το ελέγξετε, πατήστε Play και κρατήστε το Shift ενώ περπατάτε: η ταχύτητα ανεβαίνει από 16 σε 26 studs το δευτερόλεπτο, και αν το αφήσετε θα επιβραδύνετε. Για κινητό επιλέξτε ένα κινητό στο Device Simulator του Studio, πατήστε Play και πατήστε Sprint μία φορά για να ξεκινήσετε και ξανά για να σταματήσετε. Για gamepad ανοίξτε το Controller Emulator κατά το playtest και πατήστε L3. Η πλήρης λίστα ελέγχων ανά συσκευή υπάρχει στο Βήμα 6.

Τα Βήματα 2 και 3 αντικαθιστούν αυτό το script με ένα άλλο, με μπάρα stamina και dash. Τα Βήματα 4 και 5 προσθέτουν διπλό άλμα και έλεγχο στον server και δουλεύουν με οποιοδήποτε από τα δύο scripts.

Βήμα 2: οι αριθμοί stamina και dash σε ένα module

Για sprint που τελειώνει, τα Βήματα 2 και 3 αλλάζουν το ShiftToSprint με ένα μεγαλύτερο LocalScript με μπάρα stamina και dash. Πρώτα διαγράψτε το ShiftToSprint: και τα δύο scripts δένουν την ενέργεια Sprint.

Όλοι οι αριθμοί βρίσκονται σε ένα ModuleScript, οπότε η αίσθηση της κίνησης ρυθμίζεται σε ένα σημείο. Το MovementClient τους διαβάζει στη συσκευή κάθε παίκτη, και το MovementCheck διαβάζει το ίδιο module στον server, για να ξέρει ποια πρέπει να είναι η ταχύτητα του sprint και του dash.

  1. Στον Explorer περάστε τον κέρσορα πάνω από το ReplicatedStorage, πατήστε το κουμπί + και εισάγετε ένα ModuleScript.
  2. Μετονομάστε το σε MovementConfig και αντικαταστήστε το περιεχόμενο με τον κώδικα παρακάτω.
ModuleScript στο ReplicatedStorage με όνομα MovementConfig
-- Ένα σύνολο αριθμών για το LocalScript κίνησης και τον έλεγχο ταχύτητας στον server.

local MovementConfig = {
	SPRINT_BONUS = 10, -- προστίθεται στο τρέχον WalkSpeed: το 16 (η προεπιλογή του Roblox) γίνεται 26

	MAX_STAMINA = 100,
	DRAIN_PER_SECOND = 20, -- 5 δευτερόλεπτα sprint με γεμάτη μπάρα
	REGEN_PER_SECOND = 15,
	REGEN_DELAY = 1, -- δευτερόλεπτα μετά το τέλος του sprint πριν αρχίσει να αναπληρώνεται η stamina
	MIN_TO_START = 20, -- stamina που χρειάζεται για να ξεκινήσει το sprint, ώστε η άδεια μπάρα να μην αναβοσβήνει

	DASH_SPEED = 60, -- studs το δευτερόλεπτο κατά το dash
	DASH_SECONDS = 0.2, -- έτσι το dash διανύει περίπου 12 studs
	DASH_COST = 25, -- stamina
	DASH_COOLDOWN = 1,
}

return MovementConfig
Τι κάνει κάθε ρύθμιση
ΡύθμισηΤιμήΑποτέλεσμα
SPRINT_BONUS10Προστίθεται στο WalkSpeed κατά το sprint. Το προεπιλεγμένο WalkSpeed στο Roblox είναι 16, οπότε το sprint γίνεται με 26 studs το δευτερόλεπτο.
MAX_STAMINA100Γεμάτη μπάρα.
DRAIN_PER_SECOND20Μια γεμάτη μπάρα αρκεί για 5 δευτερόλεπτα sprint.
REGEN_PER_SECOND15Μια άδεια μπάρα γεμίζει σε περίπου 6.7 δευτερόλεπτα.
REGEN_DELAY1Δευτερόλεπτα ξεκούρασης πριν αρχίσει η αναπλήρωση.
MIN_TO_START20Stamina που χρειάζεται για να ξεκινήσει το sprint.
DASH_SPEED60Studs το δευτερόλεπτο κατά το dash.
DASH_SECONDS0.2Πόσο διαρκεί το dash: περίπου 12 studs με 60 studs το δευτερόλεπτο.
DASH_COST25Stamina για κάθε dash.
DASH_COOLDOWN1Δευτερόλεπτα ανάμεσα στα dash.

Κάθε πλευρά τρέχει το δικό της αντίγραφο του module (ένα module εκτελείται μία φορά σε κάθε πλευρά), οπότε ένας παίκτης που αλλάζει αυτούς τους αριθμούς στη συσκευή του αλλάζει μόνο το δικό του αντίγραφο. Αλλά εδώ αυτό δεν προστατεύει τίποτα: η συσκευή του ούτως ή άλλως κινεί τον χαρακτήρα του, οπότε μπορεί να δώσει στον εαυτό του άπειρη stamina, ό,τι κι αν λέει το module. Ο έλεγχος στον server του Βήματος 5 είναι φτιαγμένος με αυτό υπόψη.

Βήμα 3: sprint με stamina και dash

Αυτό το LocalScript κάνει ό,τι νιώθουν οι παίκτες. Δένει τα Sprint και Dash, σχεδιάζει τη μπάρα stamina, τρέχει τον βρόχο stamina σε κάθε καρέ και κάνει το dash.

  1. Στον Explorer αναπτύξτε το StarterPlayer, περάστε τον κέρσορα πάνω από το StarterPlayerScripts και εισάγετε ένα LocalScript με όνομα MovementClient.
  2. Αντικαταστήστε το περιεχόμενό του με τον κώδικα παρακάτω.
LocalScript στο StarterPlayerScripts με όνομα MovementClient
-- Κρατήστε το Shift (ή το L3, ή το κουμπί Sprint στο κινητό) για να τρέχετε όσο υπάρχει stamina.
-- Πατήστε Q (ή B, ή το κουμπί Dash) για να κάνετε dash προς την κατεύθυνση της κίνησης.

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

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

local player = Players.LocalPlayer
local stamina = Config.MAX_STAMINA
local sprintHeld = false
local sprinting = false
local normalSpeed = 16 -- το WalkSpeed στο οποίο επιστρέφουμε όταν τελειώσει το sprint
local lastSprintTime = 0
local lastDashTime = -math.huge

-- Η μπάρα stamina: ένα πλαίσιο με γέμισμα, που το πλάτος του ισούται με την stamina που απομένει
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

-- Sprint: εδώ μόνο μια σημαία· ο βρόχος Heartbeat παρακάτω αποφασίζει σε κάθε καρέ αν θα τρέχουμε
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
	-- Την αλλάζουν μόνο το πάτημα και το άφημα: ένα δάχτυλο που γλιστρά στο κουμπί αφής στέλνει Change
	if state == Enum.UserInputState.Begin then
		sprintHeld = true
	elseif state == Enum.UserInputState.End or state == Enum.UserInputState.Cancel then
		sprintHeld = false
	end
	return Enum.ContextActionResult.Pass
end

local function dash()
	local humanoid = getHumanoid()
	local rootPart = humanoid and humanoid.RootPart
	local now = os.clock()
	-- Καθιστοί δεν κάνουμε dash: ένας καθισμένος χαρακτήρας είναι κολλημένος στο κάθισμα, οπότε θα έσπρωχνε όλο το όχημα
	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 -- βάζουμε την αναπλήρωση σε παύση, όπως κάνει το sprint

	-- Dash προς τα εκεί που κινείται ο παίκτης, ή προς τα εκεί που κοιτά αν στέκεται ακίνητος
	local direction = humanoid.MoveDirection
	if direction.Magnitude < 0.1 then
		direction = rootPart.CFrame.LookVector
	end
	direction = Vector3.new(direction.X, 0, direction.Z).Unit

	-- Το LinearVelocity σε λειτουργία Plane κρατά την οριζόντια ταχύτητα και δεν εμποδίζει τη βαρύτητα
	local velocity = Instance.new("LinearVelocity")
	velocity.Attachment0 = attachment
	velocity.RelativeTo = Enum.ActuatorRelativeTo.World
	velocity.VelocityConstraintMode = Enum.VelocityConstraintMode.Plane
	velocity.PrimaryTangentAxis = Vector3.xAxis
	velocity.SecondaryTangentAxis = Vector3.zAxis
	velocity.PlaneVelocity = Vector2.new(direction.X, direction.Z) * Config.DASH_SPEED
	velocity.MaxForce = math.huge
	velocity.Parent = rootPart
	Debris:AddItem(velocity, Config.DASH_SECONDS)
end

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

-- Κάθε κλήση δένει το πλήκτρο, το κουμπί του gamepad και, σε συσκευές αφής, ένα κουμπί στην οθόνη
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")

-- Σε κάθε καρέ: ξοδεύουμε stamina κατά το sprint και την κίνηση, την αναπληρώνουμε μετά από σύντομη ξεκούραση
RunService.Heartbeat:Connect(function(deltaTime: number)
	local humanoid = getHumanoid()
	if not humanoid then
		return
	end
	local moving = humanoid.MoveDirection.Magnitude > 0
	local now = os.clock()
	local enoughStamina = if sprinting then stamina > 0 else stamina >= Config.MIN_TO_START
	local shouldSprint = sprintHeld and moving and enoughStamina

	-- Αλλάζουμε το WalkSpeed μόνο στην αρχή και στο τέλος του sprint, ώστε μια ταχύτητα που όρισε
	-- άλλο script (για παράδειγμα ένα pass ταχύτητας) να διατηρείται και το sprint να προστίθεται σε αυτήν
	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)

-- Ένας νέος χαρακτήρας ξεκινά με γεμάτη stamina και τίποτα πατημένο
player.CharacterAdded:Connect(function()
	stamina = Config.MAX_STAMINA
	sprintHeld = false
	sprinting = false -- ένα νέο Humanoid ξεκινά με το κανονικό WalkSpeed
end)

Η μπάρα stamina δημιουργείται σε κώδικα με ResetOnSpawn ίσο με false, οπότε μένει στην οθόνη μετά το respawn, και ο handler του CharacterAdded στο τέλος την ξαναγεμίζει για κάθε νέο χαρακτήρα. Οι γραμμές type Config περιγράφουν τι επιστρέφει το module, ώστε ο αυστηρός έλεγχος τύπων να πιάνει ένα ορθογραφικό λάθος στο όνομα μιας ρύθμισης· κατά το παιχνίδι δεν αλλάζουν τίποτα.

Πληκτρολόγιο, gamepad και κουμπί κινητού με μία κλήση

Το ContextActionService:BindAction δέχεται το όνομα της ενέργειας, τη συνάρτηση handler, αν πρέπει να δημιουργηθεί κουμπί αφής, και μετά τις εισόδους. Αν δώσετε true ως τρίτο όρισμα, το ContextActionService προσθέτει ένα κουμπί στην οθόνη σε συσκευές αφής, μέσα σε ένα ScreenGui με όνομα ContextActionGui στο PlayerGui του παίκτη. Το SetTitle γράφει "Sprint" και "Dash" σε αυτά τα κουμπιά. Το BindAction μπορεί να δημιουργήσει το πολύ 7 κουμπιά αφής, οπότε προσέξτε τον αριθμό αν τα χρησιμοποιούν και άλλα scripts στο παιχνίδι.

Ο handler παίρνει την κατάσταση της εισόδου: Begin στο πάτημα και End στο άφημα. Το onSprint απλώς θυμάται αν το Sprint είναι πατημένο. Μετρά ως άφημα και το Cancel, που στέλνει το ContextActionService όταν την είσοδο την παίρνει άλλο δέσιμο, και αγνοεί το Change, που μπορεί να στείλει ένα δάχτυλο που κινείται πάνω στο κουμπί αφής. Και οι δύο handlers επιστρέφουν Pass, οπότε το επόμενο δέσιμο στο ίδιο πλήκτρο παίρνει κι αυτό την είσοδο.

Η αναφορά της Roblox για το ContextActionService το προτείνει αντί για το UserInputService.InputBegan στις περισσότερες περιπτώσεις. Το παράδειγμά της: η κόρνα ενός αυτοκινήτου στο H, που δεν πρέπει να κορνάρει όσο ο παίκτης γράφει στη συνομιλία. Ένα δέσιμο ενεργοποιείται μόνο όσο είναι το τελευταίο για αυτή την είσοδο, οπότε όταν η συνομιλία παίρνει το πληκτρολόγιο δεν χρειάζεται να ελέγξετε τίποτα. Είσοδοι gamepad: ButtonL3 (πάτημα του αριστερού μοχλού, που τον κρατάτε ενώ κινείστε) και ButtonB. Το δικό της παράδειγμα sprint της Roblox χρησιμοποιεί ButtonY, οπότε αλλάξτε το KeyCode στο BindAction αν βολεύει περισσότερο το παιχνίδι σας.

Ο βρόχος stamina

Το RunService.Heartbeat ενεργοποιείται σε κάθε καρέ μετά το βήμα φυσικής και δίνει το deltaTime, τον αριθμό δευτερολέπτων από το προηγούμενο καρέ. Αν πολλαπλασιάζετε με αυτό τον ρυθμό κατανάλωσης και αναπλήρωσης, μια γεμάτη μπάρα αρκεί για 5 δευτερόλεπτα, είτε το παιχνίδι τρέχει με 30 είτε με 240 καρέ το δευτερόλεπτο.

Σε κάθε καρέ ο βρόχος αποφασίζει αν ο χαρακτήρας πρέπει να τρέχει: το Sprint είναι πατημένο, ο χαρακτήρας περπατά (το Humanoid.MoveDirection είναι μηδενικό διάνυσμα όταν στέκεται) και υπάρχει ακόμα stamina. Για να ξεκινήσει το sprint χρειάζεται τουλάχιστον MIN_TO_START (20)· για να συνεχίσει αρκεί οτιδήποτε πάνω από 0. Χωρίς αυτό το περιθώριο, μια άδεια μπάρα που γεμίζει λίγο σε κάθε καρέ θα άνοιγε και θα έκλεινε το sprint σε κάθε καρέ. Η αναπλήρωση ξεκινά REGEN_DELAY (1 δευτερόλεπτο) μετά το τελευταίο sprint ή dash, οπότε όταν αδειάσει η μπάρα ο παίκτης περιμένει περίπου 2.3 δευτερόλεπτα μέχρι να μπορεί να τρέξει ξανά.

Το WalkSpeed αλλάζει μόνο στο καρέ όπου το sprint ξεκινά ή τελειώνει. Στην αρχή το script θυμάται το τρέχον WalkSpeed και προσθέτει SPRINT_BONUS· στο τέλος επαναφέρει την τιμή που θυμήθηκε. Έτσι μια ταχύτητα που όρισε άλλο script διατηρείται: το perk Speed από τον οδηγό για τα game passes βάζει WalkSpeed 24, και με αυτό το script οι κάτοχοί του τρέχουν με 34. Ένα script που γράφει WalkSpeed = 16 σε κάθε καρέ ή σε κάθε άφημα θα ακύρωνε αθόρυβα αυτό το perk.

Το dash

Το dash σπρώχνει τον χαρακτήρα προς τα εκεί που κινείται, ή προς τα εκεί που κοιτά αν στέκεται, με την κατεύθυνση ισοπεδωμένη ώστε να μη δείχνει ποτέ πάνω ή κάτω. Κοστίζει 25 stamina, βάζει την αναπλήρωση σε παύση όπως το sprint και έχει cooldown 1 δευτερολέπτου. Δεν ελέγχει το έδαφος, οπότε δουλεύει και στον αέρα, κάτι που ταιριάζει καλά με το διπλό άλμα. Όσο ο χαρακτήρας κάθεται, το dash δεν κάνει τίποτα: ένας καθισμένος χαρακτήρας είναι κολλημένος στο κάθισμα, και σε ένα όχημα το σπρώξιμο θα μπορούσε να μετακινήσει όλο το όχημα.

Το σπρώξιμο είναι ένας περιορισμός LinearVelocity στο RootAttachment του root part. Σε λειτουργία Plane με άξονες X και Z κρατά οριζόντια ταχύτητα 60 studs το δευτερόλεπτο και δεν αγγίζει την κατακόρυφη, οπότε η βαρύτητα δουλεύει και ένα dash από μια προεξοχή πέφτει κανονικά. Το MaxForce είναι math.huge, οπότε το σπρώξιμο δεν περιορίζεται από τίποτα. Το Debris:AddItem καταστρέφει τον περιορισμό μετά από DASH_SECONDS χωρίς να κάνει το script να περιμένει, οπότε το dash διαρκεί 0.2 δευτερόλεπτα, περίπου 12 studs σε αυτή την ταχύτητα.

Τα παλιά tutorials χρησιμοποιούν BodyVelocity, που η Roblox σημείωσε ως καταργημένο με την οδηγία να χρησιμοποιείται αντί αυτού το LinearVelocity. Το κόλπο του με μηδενικό MaxForce σε έναν άξονα το αντικαθιστούν οι λειτουργίες Line, Plane και Vector του LinearVelocity. Επειδή η συσκευή του παίκτη προσομοιώνει μόνη της τον χαρακτήρα της, ένας περιορισμός που δημιούργησε ένα LocalScript τον κινεί, και οι άλλοι παίκτες βλέπουν το dash όπως κάθε άλλη κίνηση.

Το ίδιο το tutorial UI της Roblox στερεώνει τον περιορισμό στο humanoid.RootPart.RootAttachment με τον ίδιο ακριβώς τρόπο. Αν το παιχνίδι σας έχει δικό του χαρακτήρα, του οποίου το root part δεν έχει Attachment με όνομα RootAttachment, το dash δεν κάνει τίποτα: προσθέστε το στο HumanoidRootPart του StarterCharacter σας.

Βήμα 4: διπλό άλμα

Το διπλό άλμα ζει στο δικό του LocalScript στο StarterCharacterScripts. Το Roblox βάζει ένα αντίγραφο των scripts αυτού του container σε κάθε χαρακτήρα κατά το spawn, και αυτά τα αντίγραφα δεν επιβιώνουν από το respawn, οπότε κάθε ζωή ξεκινά με φρέσκο script και τίποτα δεν μεταφέρεται από την προηγούμενη.

  1. Στον Explorer αναπτύξτε το StarterPlayer, περάστε τον κέρσορα πάνω από το StarterCharacterScripts και εισάγετε ένα LocalScript με όνομα DoubleJump.
  2. Αντικαταστήστε το περιεχόμενό του με τον κώδικα παρακάτω.
LocalScript στο StarterCharacterScripts με όνομα DoubleJump
-- Δίνει ένα επιπλέον άλμα στον αέρα. Ξεκινά από την αρχή για κάθε νέο χαρακτήρα,
-- οπότε μετά το respawn τίποτα δεν μεταφέρεται.

local UserInputService = game:GetService("UserInputService")

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

local EXTRA_JUMPS = 1
local MIN_SECONDS_BETWEEN_JUMPS = 0.25 -- το JumpRequest ενεργοποιείται αρκετές φορές ανά πάτημα
local NEW_PRESS_GAP = 0.1 -- ένα πατημένο κουμπί άλματος συνεχίζει να στέλνει JumpRequest· μια παύση τέτοιας διάρκειας σημαίνει ότι αφέθηκε

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

humanoid.StateChanged:Connect(function(oldState: Enum.HumanoidStateType, newState: Enum.HumanoidStateType)
	if newState == Enum.HumanoidStateType.Jumping and oldState ~= Enum.HumanoidStateType.Freefall then
		-- Ένα άλμα από το έδαφος (όχι ένα από τα άλματά μας στον αέρα) επαναφέρει τα άλματα στον αέρα
		jumpsLeft = EXTRA_JUMPS
		lastJump = os.clock()
	elseif newState == Enum.HumanoidStateType.Landed then
		jumpsLeft = 0
	end
end)

-- Το JumpRequest ενεργοποιείται όταν ο παίκτης ζητά άλμα, για παράδειγμα με το Space ή το κουμπί άλματος στο κινητό
UserInputService.JumpRequest:Connect(function()
	local now = os.clock()
	local newPress = now - lastRequest > NEW_PRESS_GAP
	lastRequest = now
	-- Ξαναπηδά μόνο ένα νέο πάτημα, ώστε ένα πατημένο κουμπί να μη ξοδεύει το άλμα στον αέρα
	if not newPress or jumpsLeft <= 0 or now - lastJump < MIN_SECONDS_BETWEEN_JUMPS then
		return
	end
	if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
		jumpsLeft -= 1
		lastJump = now
		humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
	end
end)

Βάλτε το EXTRA_JUMPS ίσο με 2 για τριπλό άλμα.

Το script παρακολουθεί την κατάσταση του χαρακτήρα μέσω Humanoid.StateChanged. Μια μετάβαση σε Jumping που δεν ήρθε από Freefall είναι άλμα από το έδαφος, οπότε δίνει ένα άλμα στον αέρα, και το Landed το παίρνει πάλι πίσω. Αν κατεβείτε από μια προεξοχή, ο χαρακτήρας μπαίνει σε Freefall χωρίς άλμα, οπότε δεν παίρνει άλμα στον αέρα. Αν το θέλετε και εκεί, ορίζετε το jumpsLeft και στη μετάβαση σε Freefall από οποιαδήποτε κατάσταση εκτός από Jumping.

Το UserInputService.JumpRequest ενεργοποιείται όταν ο παίκτης ζητά άλμα, για παράδειγμα με το Space ή το κουμπί άλματος στο κινητό. Η αναφορά της Roblox προειδοποιεί ότι ενεργοποιείται αρκετές φορές για ένα αίτημα άλματος και προτείνει debounce, οπότε το script αγνοεί αιτήματα για 0.25 δευτερόλεπτα μετά το τελευταίο άλμα. Ένα πατημένο κουμπί άλματος μπορεί επίσης να συνεχίζει να ζητά άλματα και θα ξόδευε το άλμα στον αέρα τη στιγμή που ο χαρακτήρας ξεκολλά από το έδαφος, οπότε ένα αίτημα μετρά ως νέο πάτημα μόνο μετά από 0.1 δευτερόλεπτα χωρίς αιτήματα.

Το ίδιο το άλμα στον αέρα είναι το Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Η αναφορά της Roblox λέει ότι πρέπει να καλείται από LocalScript στη συσκευή που έχει το network ownership του χαρακτήρα, και από προεπιλογή αυτή είναι η συσκευή του ίδιου του παίκτη, όχι ο server. Το παράδειγμα κώδικα για το ChangeState στην αναφορά είναι ακριβώς ένα διπλό άλμα.

Βήμα 5: πιάνουμε speed hacks στον server

Τα tutorials για sprint συχνά σταματούν στον client. Ένα Script του server δεν μπορεί να εμπιστευτεί το WalkSpeed του παίκτη, γιατί οι exploiters το αλλάζουν στη συσκευή τους, αλλά βλέπει πού καταλήγει ο χαρακτήρας τους. Το MovementCheck το μετρά δύο φορές το δευτερόλεπτο και γράφει προειδοποίηση στο Output όταν κάποιος κινείται για πολύ πιο γρήγορα από όσο επιτρέπουν το sprint και το dash. Τους αριθμούς sprint και dash τους διαβάζει από το MovementConfig, οπότε προσθέστε αυτό το module από το Βήμα 2 ακόμα κι αν κρατήσατε το ShiftToSprint.

  1. Περάστε τον κέρσορα πάνω από το ServerScriptService και εισάγετε ένα Script με όνομα MovementCheck.
  2. Αντικαταστήστε το περιεχόμενό του με τον κώδικα παρακάτω.
Script στο ServerScriptService με όνομα MovementCheck
-- Οι συσκευές των παικτών κινούν τους χαρακτήρες τους, οπότε ένας exploiter μπορεί να βάλει οποιοδήποτε WalkSpeed.
-- Αυτός ο έλεγχος μετρά πόσο μακριά κινείται πραγματικά κάθε χαρακτήρας και γράφει στο Output
-- όταν κάποιος κινείται για πολύ πιο γρήγορα από όσο επιτρέπουν το sprint και το dash. Μόνο προειδοποιεί:
-- lag, τηλεμεταφορές και ταινίες μεταφοράς μπορεί να μοιάζουν με υπερβολική ταχύτητα, οπότε ρυθμίστε τον πριν τιμωρήσετε κανέναν.

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 -- δευτερόλεπτα
-- Ταχύτητα sprint συν περιθώριο για lag. Αυξήστε το αν πουλάτε επιταχύνσεις.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- περιθώριο για ένα ή δύο dash
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- πόσο γρήγορα συγχωρούνται τα παλιά dash

local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- το root part πάνω στο οποίο μετρήθηκε το lastPosition
local excess: { [Player]: number } = {} -- studs πάνω από το επιτρεπτό, συγχωρούνται σταδιακά

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
			-- Ένα respawn είναι νέο root part, και μια τηλεμεταφορά από τον server (έναρξη γύρου, checkpoint)
			-- βάζει το attribute παρακάτω: αρχίζουμε να μετράμε από την αρχή αντί να επισημάνουμε το άλμα
			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
				-- Μόνο οριζόντια κίνηση: το να πέφτεις γρήγορα δεν είναι cheat
				local moved = Vector3.new(position.X - previous.X, 0, position.Z - previous.Z).Magnitude
				local extra = moved - SPEED_ALLOWANCE * CHECK_EVERY
				local total = math.max(0, (excess[player] or 0) + extra - DRAIN_PER_CHECK)
				excess[player] = total
				if total > BURST_ALLOWANCE then
					warn(`MovementCheck: {player.Name} moved {math.round(moved / CHECK_EVERY)} studs/s`)
					excess[player] = 0
				end
			end
		else
			lastPosition[player] = nil
			lastRoot[player] = nil
		end
	end
end

Η προειδοποίηση εμφανίζεται στο Output στο Studio. Στο ζωντανό παιχνίδι καταλήγει στο log του server στο Developer Console, που μπορείτε να διαβάζετε ως ιδιοκτήτης του παιχνιδιού: δείτε την έξοδο στο ζωντανό παιχνίδι.

Τι μετρά

Κάθε μισό δευτερόλεπτο το script διαβάζει τη θέση του root part κάθε χαρακτήρα και μετρά πόσο μετακινήθηκε οριζόντια από τον προηγούμενο έλεγχο. Το ύψος αγνοείται, οπότε πτώσεις και άλματα δεν μετρούν ποτέ· η συμβουλή της Roblox για τον έλεγχο κίνησης προτείνει την ίδια προβολή στο επίπεδο XZ για παιχνίδια όπου περπατάς στο έδαφος. Το επιτρεπτό όριο είναι η προεπιλεγμένη ταχύτητα περπατήματος συν το μπόνους sprint και άλλο ένα τέταρτο για το lag: 32.5 studs το δευτερόλεπτο. Η απόσταση πάνω από αυτό μπαίνει σε έναν «κουβά που στάζει» (leaky bucket), έναν συσσωρευτή για τον οποίο η τεκμηρίωση της Roblox λέει ότι ταιριάζει καλά σε πολλούς developers για σύντομες εκρήξεις. Ο κουβάς χάνει 3 studs σε κάθε έλεγχο, και το script προειδοποιεί όταν περιέχει πάνω από 24 studs, δηλαδή περιθώριο για περίπου δύο dash.

Τι πιάνει ο έλεγχος, αν υπολογίσουμε με τους αριθμούς του
CheaterΤι κάνει το MovementCheck
Βάζει WalkSpeed 100Προειδοποιεί μετά από περίπου ένα δευτερόλεπτο τρεξίματος
Βάζει WalkSpeed 50Προειδοποιεί μετά από περίπου 2.5 δευτερόλεπτα τρεξίματος
Κάνει dash συνεχόμενα χωρίς cooldown (60 studs το δευτερόλεπτο)Προειδοποιεί μετά από περίπου 1.5 δευτερόλεπτο
Τηλεμεταφέρεται πάνω από 43 studs τη φοράΠροειδοποιεί στον επόμενο έλεγχο
Τρέχει με έως 38 studs το δευτερόλεπτο, περίπου μιάμιση φορά πιο γρήγορα από το sprintΤίποτα: κάτω από 38.5 studs το δευτερόλεπτο ο κουβάς αδειάζει τόσο γρήγορα όσο γεμίζει
Αλλάζει το δικό του MovementConfig για άπειρη staminaΤίποτα: το sprint με 26 studs το δευτερόλεπτο επιτρέπεται για όσο θέλει
Πετά, πηδά χωρίς όρια ή περνά μέσα από τοίχουςΤίποτα: ο έλεγχος αγνοεί το ύψος και δεν κοιτά τις συγκρούσεις

Άρα ο έλεγχος πιάνει τα χοντρά cheats, όπου ο παίκτης είναι εμφανώς πιο γρήγορος από όλους τους άλλους, και αφήνει να περάσουν τα προσεκτικά. Αυτό είναι το τίμιο όριο ενός ελέγχου απόστασης και ο λόγος που η Roblox φτιάχνει κάτι πιο δυνατό (δείτε το server authority παρακάτω).

Γιατί μόνο προειδοποιεί

Η τεκμηρίωση της Roblox σημειώνει ότι οι απλοί έλεγχοι ταχύτητας μπορεί να επισημαίνουν τίμιους παίκτες με ασταθή σύνδεση και χαλάνε σε παιχνίδια με οχήματα ή άλλη σύνθετη κίνηση. Άλματα lag, ταινίες μεταφοράς, οχήματα, εκρήξεις που πετούν τους χαρακτήρες και οι δικές σας τηλεμεταφορές μπορεί να μοιάζουν με υπερβολική ταχύτητα, οπότε το script απλώς τυπώνει προειδοποίηση. Κοιτάτε το Output ενώ εσείς και οι testers σας παίζετε κανονικά, αυξήστε το SPEED_ALLOWANCE αν σκοντάφτουν πάνω του τίμιοι παίκτες, και προσθέτετε τιμωρία, για παράδειγμα επιστροφή του παίκτη πίσω, μόνο όταν ο έλεγχος σωπαίνει στο κανονικό παιχνίδι. Αν στο παιχνίδι σας εκρήξεις πετούν τους χαρακτήρες, παραλείπετε επίσης τους παίκτες των οποίων το Humanoid δεν έχει πια υγεία.

Respawns και τηλεμεταφορές

Ένα respawn δημιουργεί νέο root part, και το script αρχίζει να μετρά από την αρχή όταν το δει, οπότε ένας θάνατος μακριά από το σημείο spawn δεν μετρά ποτέ ως υπερβολική ταχύτητα. Οι τηλεμεταφορές που κάνουν τα δικά σας scripts στον server χρειάζονται εξαίρεση, όπως λέει η τεκμηρίωση της Roblox για κάθε παιχνίδι με τηλεμεταφορές. Μετά από μια τηλεμεταφορά προσθέστε player:SetAttribute("MovementCheckSkip", true), και ο επόμενος έλεγχος θα αρχίσει να μετρά από τη νέα θέση αντί να επισημάνει το άλμα:

Οι πλατφόρμες και τα μενού από τον οδηγό για την τηλεμεταφορά και η πλατφόρμα Finish από τον οδηγό για το πρώτο παιχνίδι το βάζουν ήδη μετά από κάθε μετακίνηση.

Μετρά μόνο η τιμή από τον server. Ένα attribute που βάζει ο παίκτης στη συσκευή του μένει σε αυτή τη συσκευή (δείτε τι αναπαράγεται και τι όχι), οπότε ένας cheater δεν μπορεί να απενεργοποιήσει τον έλεγχο με αυτό.

Η λύση για το μέλλον: server authority

Η τεκμηρίωση ασφάλειας της Roblox ονομάζει το μοντέλο server authority, που τη στιγμή που γράφονται αυτά είναι σε beta, τον πιο αξιόπιστο τρόπο να σταματήσουν τα exploits κίνησης. Πηγή της αλήθειας γίνεται ο server, και οι συσκευές των παικτών αναφέρουν μόνο την είσοδό τους, κάτι που σύμφωνα με την τεκμηρίωση εμποδίζει τα speed hacks να δουλέψουν, γιατί η συσκευή δεν εμπιστεύεται ποτέ να αναφέρει τη δική της θέση.

Η μετάβαση είναι ξαναγράψιμο, όχι ρύθμιση. Σε αυτό το μοντέλο την κίνηση τη υπολογίζει ο server, οπότε ένα WalkSpeed ή LinearVelocity που ορίζει μόνο ένα LocalScript ακυρώνεται όταν φτάνει η κατάσταση από τον server. Η τεκμηρίωση της Roblox λέει ότι η βασική λογική πρέπει να τρέχει σε συναρτήσεις RunService:BindToSimulation() σε ένα ModuleScript που το τρέχουν και ο client και ο server. Το μοντέλο χρειάζεται επίσης μερικές ρυθμίσεις του Workspace, μεταξύ αυτών το PlayerScriptsUseInputActionSystem, οπότε και ο χειρισμός σας θα μετακομίσει στο Input Action System. Κρατήστε την εκδοχή αυτού του οδηγού μέχρι να μεταφέρετε το sprint, την stamina και το dash σε αυτό το σχήμα. Μέχρι τότε, ένας έλεγχος απόστασης όπως αυτός είναι ακριβώς ό,τι περιγράφει η ενότητα της Roblox για τον έλεγχο κίνησης.

Βήμα 6: δοκιμάστε σε κάθε συσκευή

  1. Πατήστε Play και κρατήστε το Shift ενώ περπατάτε. Η ταχύτητα ανεβαίνει από 16 σε 26 studs το δευτερόλεπτο, και η πράσινη μπάρα στο κάτω μέρος της οθόνης μικραίνει. Μετά από περίπου 5 δευτερόλεπτα είναι άδεια και περπατάτε ξανά.
  2. Αφήστε το Shift. Μετά από 1 δευτερόλεπτο η μπάρα αρχίζει να γεμίζει. Μέχρι να γεμίσει κατά ένα πέμπτο, το Shift δεν κάνει τίποτα.
  3. Πατήστε Q ενώ περπατάτε: τινάζεστε λίγο μπροστά και ένα τέταρτο της μπάρας χάνεται. Πατήστε αμέσως ξανά Q και δεν θα συμβεί τίποτα μέχρι να περάσει ένα δευτερόλεπτο. Αν το dash φαίνεται πολύ μικρό ή πολύ μεγάλο, αλλάξτε το DASH_SPEED ή το DASH_SECONDS στο MovementConfig.
  4. Πηδήξτε και μετά πατήστε ξανά άλμα στον αέρα για δεύτερο άλμα. Προσγειωθείτε και δοκιμάστε ξανά: κάθε άλμα από το έδαφος επαναφέρει το άλμα στον αέρα.
  5. Κρατήστε το Space πατημένο σε όλο το άλμα. Πρέπει να βγει ένα άλμα, όχι δύο, γιατί το άλμα στον αέρα χρειάζεται νέο πάτημα.
  6. Ενεργοποιήστε το Device Simulator στο Studio (τη στιγμή που γράφονται αυτά είναι beta: File, Beta Features, New Device Simulator, μετά επανεκκινήστε το Studio) ή ενεργοποιήστε τον παλιό Device Emulator στο μενού Test. Επιλέξτε ένα κινητό και πατήστε Play. Θα εμφανιστούν τα κουμπιά Sprint και Dash. Κρατήστε το Sprint ενώ κατευθύνετε, μετά κρατήστε το κουμπί άλματος σε όλο το άλμα και ελέγξτε ότι το άλμα είναι μόνο ένα.
  7. Ανοίξτε το Controller Emulator (Controller στην καρτέλα Emulation ή Virtual controller στο πάνελ του Device Simulator). Κρατήστε το L3 ενώ κινείστε για να τρέξετε, πατήστε B για dash και A δύο φορές για διπλό άλμα.
  8. Κάντε reset τον χαρακτήρα από το μενού του παιχνιδιού. Η μπάρα είναι πάλι γεμάτη, στο Output δεν υπάρχει προειδοποίηση MovementCheck, και αν ακόμα προσομοιώνετε κινητό, τα κουμπιά Sprint και Dash είναι στη θέση τους.
  9. Τώρα παίξτε ως cheater. Πατάτε τον διακόπτη Client/Server μέχρι ο Explorer να δείξει τον client, επιλέξτε το Humanoid του χαρακτήρα σας στο Workspace και βάλτε το WalkSpeed ίσο με 60 στο παράθυρο Properties. Περπατήστε μερικά δευτερόλεπτα: στο Output θα εμφανιστεί μια προειδοποίηση όπως MovementCheck: YourName moved 60 studs/s. Επαναφέρετε το 16, μετά για ένα λεπτό τρέξτε και κάντε dash κανονικά και ελέγξτε ότι το Output σωπαίνει.
  10. Αν στο place σας το Workspace.PlayerScriptsUseInputActionSystem είναι Enabled, δοκιμάστε ξανά το διπλό άλμα: η τεκμηρίωση της Roblox δεν λέει αν το JumpRequest συμπεριφέρεται με αυτό με τον ίδιο τρόπο.

Αν δεν συμβαίνει απολύτως τίποτα, ανοίξτε το παράθυρο Output από το μενού Window στο Studio και ψάξτε για κόκκινο σφάλμα από το MovementClient ή ρίξτε μια ματιά στα συνηθισμένα σφάλματα.

Πόσο γρήγορα και για πόσο: presets ανά είδος παιχνιδιού

Το σωστό sprint εξαρτάται από το παιχνίδι. Ένα κυνηγητό σε παιχνίδι τρόμου θέλει σύντομο, αργό sprint που τελειώνει την πιο άβολη στιγμή· ένας μεγάλος ανοιχτός χάρτης θέλει μακρύ, ώστε οι παίκτες να μη βαριούνται να τον διασχίζουν. Αυτά τα presets χρησιμοποιούν τα ίδια scripts και αλλάζουν μόνο την ταχύτητα περπατήματος και το MovementConfig. Είναι δικά μας σημεία εκκίνησης, υπολογισμένα από τις ρυθμίσεις, όχι μετρημένα σε παίκτες.

Ταχύτητα περπατήματος, sprint και stamina ανά είδος παιχνιδιού. Ο χρόνος sprint είναι MAX_STAMINA / DRAIN_PER_SECOND· η αναπλήρωση είναι MAX_STAMINA / REGEN_PER_SECOND συν 1 δευτερόλεπτο REGEN_DELAY
Είδος παιχνιδιούCharacterWalkSpeedSPRINT_BONUS (ταχύτητα sprint)DRAIN_PER_SECONDREGEN_PER_SECONDΠλήρες sprintΑπό άδεια σε γεμάτηΑπόσταση με μία μπάρα
Αυτός ο οδηγός1610 (26)20155 δευτ.7.7 δευτ.130 studs
Κυνηγητό σε παιχνίδι τρόμου128 (20)25104 δευτ.11 δευτ.80 studs
Battlegrounds και μάχη1612 (28)15206.7 δευτ.6 δευτ.περίπου 187 studs
Ανοιχτός κόσμος ή simulator1616 (32)102510 δευτ.5 δευτ.320 studs
Obby ή parkour168 (24)χωρίς stamina: χρησιμοποιήστε το ShiftToSprint
  • Η ταχύτητα περπατήματος ορίζεται στο StarterPlayer. Επιλέξτε το StarterPlayer και ορίστε το CharacterWalkSpeed (προεπιλογή 16). Κάθε νέος χαρακτήρας ξεκινά με αυτή την ταχύτητα, το sprint της προσθέτει SPRINT_BONUS, και το MovementCheck τη διαβάζει επίσης, οπότε ο έλεγχος στον server ακολουθεί την επιλογή σας.
  • Το MovementCheck προσαρμόζεται. Επιτρέπει την ταχύτητα περπατήματος συν το μπόνους sprint και άλλο ένα τέταρτο για το lag: 25 studs το δευτερόλεπτο για το preset τρόμου, 40 για τον ανοιχτό κόσμο. Δεν χρειάζεται να αλλάξετε τίποτα άλλο.
  • Σε ένα obby το sprint αλλάζει την πίστα. Με πιο γρήγορο sprint πηδιούνται μεγαλύτερα κενά. Χτίστε τα άλματα και μετά ελέγξτε το καθένα με ταχύτητα sprint, αλλιώς το sprint θα κάνει τα στάδια πολύ εύκολα. Ο οδηγός για checkpoints σε obby ταιριάζει καλά με το ShiftToSprint.
  • Σε παιχνίδι τρόμου μέτρο είναι ο δολοφόνος. Κάντε τον διώκτη λίγο πιο γρήγορο από την ταχύτητα περπατήματος και λίγο πιο αργό από το sprint, ώστε η διαφυγή να εξαρτάται από το πότε θα τελειώσει η μπάρα. Ο οδηγός για παιχνίδι τρόμου αναλύει τον υπόλοιπο βρόχο.

Τι δεν πάει καλά με τα παλιά scripts για sprint

Τα παλιά tutorials για sprint, dash και διπλό άλμα συχνά δουλεύουν ακόμα, αλλά πολλά χρησιμοποιούν τεχνικές που η Roblox έχει από τότε αντικαταστήσει, ή χαλάνε άλλα συστήματα στο παιχνίδι σας. Αν διορθώνετε ένα αντιγραμμένο script, συγκρίνετέ το με αυτή τη λίστα.

Τεχνικές από παλιά tutorials και τι κάνει αυτός ο οδηγός στη θέση τους
ΤεχνικήΠοιο είναι το πρόβλημαΑυτός ο οδηγός
BodyVelocity για το dashΚαταργημένο: η Roblox λέει να χρησιμοποιείται στη θέση του το LinearVelocityLinearVelocity σε λειτουργία Plane
Βρόχος στο RunService.RenderSteppedΓια νέα δουλειά το έχει αντικαταστήσει το PreRender. Η λογική παιχνιδιού όπως η stamina ανήκει στο Heartbeat, που η Roblox περιγράφει για περιοδικές εργασίες όπως η αναπλήρωση υγείαςHeartbeat με deltaTime
Βρόχος stamina με wait()Το wait() έχει καταργηθεί υπέρ του task.wait() και καθυστερεί, οπότε μπορεί να περιμένει περισσότερο από όσο ζητήθηκε, και μια σταθερή κατανάλωση ανά wait ξοδεύει την stamina άνισαΚατανάλωση και αναπλήρωση σε κάθε καρέ με βάση το deltaTime
UserInputService.InputBegan χωρίς έλεγχο συνομιλίαςΈνα πάτημα του Shift ενώ γράφετε μήνυμα στη συνομιλία ξεκινά το sprintContextActionService, που προσθέτει επίσης κουμπί στο κινητό
WalkSpeed = 16 στο άφημα ή σε κάθε καρέΓράφει πάνω σε κάθε άλλη ταχύτητα, για παράδειγμα σε ένα perk game passΑλλάζει το WalkSpeed μόνο στην αρχή και στο τέλος του sprint, προσθέτοντας στην τρέχουσα τιμή
Sprint μέσω RemoteEvent ώστε το WalkSpeed να το ορίζει ο serverΟι exploiters ούτως ή άλλως ορίζουν μόνοι τους το WalkSpeed, και το sprint ξεκινά με καθυστέρηση μετ' επιστροφήςSprint στον client συν έλεγχος απόστασης στον server
Διπλό άλμα σε κάθε JumpRequestΤο JumpRequest ενεργοποιείται αρκετές φορές για ένα αίτημα άλματος, και ένα πατημένο κουμπί μπορεί να συνεχίζει να ζητά άλματαΠαύση 0.25 δευτερολέπτων και έλεγχος νέου πατήματος
UserInputService.TouchEnabled ως έλεγχος «είναι κινητό»Είναι true σε laptops με οθόνη αφήςΤο ContextActionService προσθέτει κουμπιά στην οθόνη σε συσκευές αφής χωρίς δικό σας έλεγχο συσκευής
Humanoid:LoadAnimation για animation τρεξίματοςΚαταργημένο υπέρ του Animator:LoadAnimationΗ animation τρεξίματος παρακάτω χρησιμοποιεί Animator

Ο νέος τρόπος της Roblox: Input Action System

Η σελίδα της Roblox για το Input Action System παίρνει ως πρώτο παράδειγμα το sprint του χαρακτήρα. Αντί για κλήσεις BindAction, ο χειρισμός ρυθμίζεται στο Studio: ένα InputAction με όνομα CharacterSprint μέσα σε ένα input context στο ReplicatedStorage, με ένα InputBinding για το Left Shift, ένα για το κουμπί Y του gamepad και ένα συνδεδεμένο με ένα κουμπί στην οθόνη που σχεδιάζετε στο StarterGui. Μετά ένα script του client ακούει τα events Pressed και Released της ενέργειας, διπλασιάζοντας το WalkSpeed στο πάτημα και επαναφέροντάς το στο άφημα.

Αξίζει να περάσετε σε αυτό αν θέλετε να στήνετε τον χειρισμό στο Studio και όχι σε κώδικα, ένα δικό σας κουμπί αφής αντί για το κουμπί του ContextActionService, ή contexts που αλλάζουν ολόκληρα σύνολα χειρισμού, για παράδειγμα για μενού ή οχήματα. Η σελίδα προτείνει επίσης να βάλετε το Workspace.PlayerScriptsUseInputActionSystem σε Enabled, και το server authority το απαιτεί.

Ο βρόχος stamina και το dash αυτού του οδηγού δουλεύουν το ίδιο με σκέτο το Input Action System (χωρίς server authority). Κρατήστε το MovementConfig, τον βρόχο Heartbeat και το dash(), διαγράψτε τις δύο κλήσεις BindAction και τους handlers τους και συνδέστε στη θέση τους τις ενέργειες: το Pressed της ενέργειας sprint βάζει το sprintHeld σε true και το Released της σε false, και το Pressed της ενέργειας dash καλεί το dash(). Συνεχίστε να βρίσκετε το Humanoid σε κάθε καρέ, όπως κάνει το MovementClient, γιατί το παράδειγμα της τεκμηρίωσης κρατά το Humanoid του πρώτου χαρακτήρα, και μετά το respawn αυτό δεν υπάρχει πια.

Η Roblox δοκιμάζει επίσης το Character Controller Library, μια beta που ενεργοποιείται στα Beta Features και στα Avatar Settings του Studio. Η σελίδα του για τις δικές σας ικανότητες χτίζει ως παράδειγμα ένα dash με ενεργό παράθυρο 0.2 δευτερολέπτων και cooldown 1 δευτερολέπτου, δηλαδή με τον ίδιο χρονισμό που έχει το dash αυτού του οδηγού.

Πώς να το επεκτείνετε: animation, κάμερα και pass για sprint

Animation τρεξίματος

Φτιάξτε μια animation τρεξίματος στο Animation Editor, δώστε της προτεραιότητα Movement (η Roblox τη συνιστά για animations περπατήματος και τρεξίματος), δημοσιεύστε την και αντιγράψτε το ID του asset. Στο MovementClient δημιουργήστε ένα Animation με αυτό το AnimationId, φορτώστε το μέσω Animator:LoadAnimation, χρησιμοποιώντας τον Animator μέσα στο Humanoid του χαρακτήρα, ξεκινάτε το track εκεί όπου ξεκινά το sprint και το σταματάτε εκεί όπου τελειώνει. Φορτώνετέ το ξανά για κάθε νέο χαρακτήρα.

Τις animations που ξεκινά η συσκευή σας στον χαρακτήρα σας τις βλέπουν όλοι, αν χρησιμοποιείτε τον Animator που έβαλε εκεί η Roblox: tracks φορτωμένα σε Animator που δημιούργησε ένα LocalScript δεν αναπαράγονται. Το Humanoid:LoadAnimation, που χρησιμοποιούν πολλά παλιά tutorials, έχει καταργηθεί.

Πιο ανοιχτή κάμερα κατά το sprint

Μια λίγο πιο ανοιχτή γωνία θέασης κάνει το sprint να μοιάζει πιο γρήγορο. Στα ίδια δύο σημεία κάντε tween το workspace.CurrentCamera.FieldOfView από την προεπιλεγμένη τιμή 70 σε περίπου 80 όταν ξεκινά το sprint, και πίσω όταν τελειώνει, για παράδειγμα με TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Η Roblox περιορίζει την τιμή από 1 έως 120 και προειδοποιεί ότι πολύ χαμηλές ή πολύ υψηλές τιμές μπορεί να αποπροσανατολίσουν τους παίκτες. Αν τη γωνία θέασης την αλλάζει και κάποιο άλλο script στο παιχνίδι, κάνετε tween πίσω στην τιμή που βρήκατε, όχι στο 70.

Γρήγορο sprint ως game pass

Ο οδηγός για τα game passes δουλεύει ήδη με αυτό το script: το perk Speed του βάζει στον server WalkSpeed 24 σε κάθε νέο χαρακτήρα, το MovementClient προσθέτει από πάνω το μπόνους sprint, και τα 34 studs το δευτερόλεπτο μένουν μέσα σε όσα επιτρέπει το MovementCheck.

Για ένα pass που επιταχύνει το ίδιο το sprint, προσθέστε ένα pass FastSprint στο PassConfig.ids εκείνου του οδηγού. Το script του στον server τότε βάζει στον παίκτη το attribute OwnsPass_FastSprint μόλις επιβεβαιωθεί η αγορά. Στο MovementClient χρησιμοποιήστε μπόνους μεγαλύτερο από το Config.SPRINT_BONUS όταν player:GetAttribute("OwnsPass_FastSprint") == true. Στο MovementCheck δώστε σε αυτούς τους παίκτες μεγαλύτερο περιθώριο, διαβάζοντας το ίδιο attribute στον server, όπου ο παίκτης δεν μπορεί να το αλλάξει, και ελέγξτε ότι η νέα μέγιστη ταχύτητα μένει κάτω από αυτό που επισημαίνει ο έλεγχος.

Ένας περιορισμός που αξίζει να ξέρετε: αν άλλο script αλλάξει το WalkSpeed στη μέση ενός sprint, το τέλος αυτού του sprint θα επαναφέρει την ταχύτητα που υπήρχε πριν από αυτό. Το επόμενο respawn θα ξαναβάλει την ταχύτητα του pass, γιατί το script του game pass την εφαρμόζει σε κάθε νέο χαρακτήρα.

Συνηθισμένα λάθη και λύσεις

Ανοίξτε το παράθυρο Output (μενού Window, μετά Output) πριν πατήσετε Play. Τα περισσότερα προβλήματα με αυτά τα scripts τυπώνουν εκεί ένα σφάλμα ή μια προειδοποίηση με το όνομα του script και τον αριθμό γραμμής.

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

Το MovementClient ή το MovementCheck περιμένει ένα module που δεν υπάρχει με ακριβώς αυτό το όνομα. Πρέπει να είναι ModuleScript με όνομα MovementConfig απευθείας μέσα στο ReplicatedStorage. Ο οδηγός για τα σφάλματα στα scripts αναλύει αυτή την προειδοποίηση λεπτομερώς.

Το Shift δεν κάνει τίποτα

Ελέγξτε ότι το ShiftToSprint ή το MovementClient είναι LocalScript, όχι Script, και ότι βρίσκεται στο StarterPlayerScripts. Με το MovementClient, για να ξεκινήσει το sprint ο χαρακτήρας πρέπει επίσης να περπατά και να έχει τουλάχιστον 20 stamina, οπότε κρατάτε το Shift ενώ κινείστε. Αν αντί για sprint εναλλάσσεται το Shift Lock, δείτε την ερώτηση για το Shift Lock παρακάτω.

Το sprint σταματά μετά από λίγα δευτερόλεπτα

Τελειώνει η stamina: 100 stamina με 20 το δευτερόλεπτο αρκούν για 5 δευτερόλεπτα. Αυξήστε το MAX_STAMINA ή μειώστε το DRAIN_PER_SECOND στο MovementConfig.

Το dash δεν κάνει τίποτα

Το dash χρειάζεται 25 stamina, περιμένει 1 δευτερόλεπτο μετά το προηγούμενο και δεν κάνει τίποτα όσο κάθεστε. Αν δεν φταίει αυτό, το root part του χαρακτήρα σας μπορεί να μην έχει Attachment με όνομα RootAttachment, όπως συμβαίνει με κάποιους δικούς σας χαρακτήρες: προσθέστε το στο HumanoidRootPart του StarterCharacter σας.

Το διπλό άλμα δεν ενεργοποιείται

Το DoubleJump πρέπει να είναι LocalScript στο StarterCharacterScripts, όχι στο StarterPlayerScripts, γιατί διαβάζει το script.Parent ως χαρακτήρα. Πατήστε άλμα δεύτερη φορά αφού ξεκολλήσετε από το έδαφος: ένα πατημένο κουμπί δεν μετρά ως νέο πάτημα, και το να κατεβείτε από μια προεξοχή δεν δίνει άλμα στον αέρα.

Στο κινητό δεν υπάρχει κουμπί Sprint ή Dash

Το ContextActionService προσθέτει τα κουμπιά του μόνο σε συσκευές αφής, οπότε σε PC χωρίς οθόνη αφής δεν φαίνονται ποτέ. Δοκιμάζετε με ένα κινητό στο Device Simulator του Studio (είναι beta: ενεργοποιήστε το New Device Simulator στο File, Beta Features και επανεκκινήστε το Studio). Το BindAction μπορεί να δημιουργήσει το πολύ 7 κουμπιά αφής, οπότε μετρήστε πόσα φτιάχνουν άλλα scripts στο παιχνίδι.

Το MovementCheck παραπονιέται για τίμιους παίκτες

Οι συνηθισμένες αιτίες: τηλεμεταφορά από άλλο script του server, ταινία μεταφοράς ή όχημα, ή lag. Βάζετε το attribute MovementCheckSkip μετά από τις τηλεμεταφορές σας (δείτε Respawns και τηλεμεταφορές) και αυξήστε το SPEED_ALLOWANCE αν ο έλεγχος ενεργοποιείται ακόμα στο κανονικό παιχνίδι.

Η επιτάχυνση χάνεται μετά το sprint

Άλλο script άλλαξε το WalkSpeed κατά το sprint, και το sprint, όταν τελείωσε, επανέφερε την ταχύτητα που είδε στην αρχή. Δίνετε τις επιταχύνσεις στο spawn του χαρακτήρα, όπως κάνει ο οδηγός για τα game passes, ώστε το respawn να ξαναβάζει τη σωστή ταχύτητα.

Φτιάξτε το με το RoCode

Αν δεν θέλετε να τα ρυθμίσετε όλα αυτά με το χέρι, το RoCode μπορεί να τα φτιάξει στο place που έχετε ανοιχτό. Το RoCode είναι ένας ανεξάρτητος πράκτορας AI για το Roblox Studio, όχι από τη Roblox: περιγράφετε την αλλαγή στη web συνομιλία και το plugin του για το Studio δημιουργεί τα scripts στον Explorer σας, οπότε δεν χρειάζεται να επικολλήσετε κώδικα.

Εσείς γράφετε

Πρόσθεσε sprint με Shift με μπάρα stamina: ταχύτητα περπατήματος συν 10 όσο είναι πατημένο το Shift, 100 stamina, κατανάλωση 20 το δευτερόλεπτο, αναπλήρωση 15 το δευτερόλεπτο μετά από ένα δευτερόλεπτο ξεκούρασης, κουμπί Sprint στα κινητά, dash με Q και διπλό άλμα.

Το RoCode κάνει
  • Μπορεί πρώτα να εξετάσει το place σας μέσω Search Scripts και Read Script για να βρει άλλα scripts που αλλάζουν το WalkSpeed (για παράδειγμα ένα perk game pass), ώστε το sprint να προστίθεται σε αυτά
  • Γράφει το ModuleScript, τα LocalScripts και τον έλεγχο στον server μέσω Create Script
  • Έχει οδηγία να ελέγχει τη μεταγλώττιση κάθε script που γράφει μέσω Check Script, που το μεταγλωττίζει στο Studio χωρίς να το εκτελεί
  • Βάζει σημείο αναίρεσης πριν και μετά από κάθε δέσμη αλλαγών, οπότε το Ctrl+Z αναιρεί μία δέσμη τη φορά

Το RoCode δεν μπορεί να φτιάξει animation τρεξίματος: δημιουργήστε την στο Animation Editor και επικολλήστε το ID της. Με plugin 3.9.11 ή νεότερο το RoCode μπορεί να τρέξει playtest του παιχνιδιού σας στο Studio και να χειρίζεται έναν δοκιμαστικό χαρακτήρα για να ελέγξει ότι όλα δουλεύουν, και με plugin 3.9.15 ή νεότερο ο δοκιμαστικός χαρακτήρας μπορεί να πατά πλήκτρα, για παράδειγμα να κρατά το Shift και να ελέγχει ότι το WalkSpeed ανέβηκε. Αποφασίζει μόνο του πότε θα τρέξει playtest, έως 2 ανά χτίσιμο συν 1 για τον έλεγχο της διόρθωσής του, και ελέγχει μόνο ό,τι αποφάσισε το ίδιο να δοκιμάσει, οπότε δοκιμάστε μόνοι σας το sprint, το dash και το διπλό άλμα, και ελέγξτε τα κουμπιά του κινητού στο Device Simulator του Studio. Η κίνηση είναι ένα σύστημα από τα πολλά ενός παιχνιδιού· η δημιουργία ολόκληρου παιχνιδιού με το RoCode προχωρά ένα σύστημα ανά prompt, όπως εδώ. Πώς συνδέεται το RoCode με το Studio.

Συχνές ερωτήσεις

Γιατί το script για sprint δεν δουλεύει στο κινητό;

Το κινητό δεν έχει πλήκτρο Shift. Δένετε το sprint μέσω ContextActionService:BindAction και δίνετε true ως τρίτο όρισμα: αυτό προσθέτει κουμπί στην οθόνη σε συσκευές αφής, όπως κάνουν και το ShiftToSprint και το MovementClient.

Πρέπει να κάνω το sprint στον server;

Όχι. Κάθε συσκευή κινεί τον δικό της χαρακτήρα, οπότε ένα WalkSpeed που ορίζει ο server δεν θα σταματήσει έναν cheater που μπορεί να ορίσει το δικό του, και η νέα ταχύτητα φτάνει μόνο μετά από μια διαδρομή μετ' επιστροφής, οπότε το sprint ξεκινά με καθυστέρηση. Κάνετε το sprint στον client, και στον server ελέγχετε πόσο μακριά κινούνται πραγματικά οι χαρακτήρες, όπως στο Βήμα 5. Η beta server authority της Roblox λειτουργεί διαφορετικά, και ο κώδικας κίνησης για αυτήν θα πρέπει να ξαναγραφτεί.

Γιατί ο χαρακτήρας συνεχίζει να τρέχει όταν αφήνω το Shift;

Το script έχασε το άφημα, συνήθως επειδή ακούει μόνο το πάτημα. Το ContextActionService στέλνει End όταν αφήνεται το πλήκτρο και Cancel όταν το παίρνει άλλο δέσιμο· το MovementClient σταματά και στα δύο, καθώς και όταν τελειώνει η stamina ή ο χαρακτήρας σταματά να κινείται.

Πώς προσθέτω animation τρεξίματος;

Φορτώστε μια animation τρεξίματος μέσω του Animator στο Humanoid του χαρακτήρα στο ίδιο LocalScript, ξεκινάτε την όταν ξεκινά το sprint και σταματάτε την όταν τελειώνει. Δώστε της προτεραιότητα Movement. Τις animations που ξεκινούν στον δικό σας χαρακτήρα τις βλέπουν όλοι.

Γιατί το διπλό άλμα στο κινητό ενεργοποιείται μόνο του;

Ένα πατημένο κουμπί άλματος στο κινητό συνεχίζει να ζητά άλματα. Μετράτε ένα άλμα ως νέο μόνο αν τα αιτήματα σταμάτησαν για μια στιγμή, όπως κάνει το script DoubleJump.

Ποια είναι η προεπιλεγμένη ταχύτητα περπατήματος στο Roblox;

16 studs το δευτερόλεπτο. Προέρχεται από το StarterPlayer.CharacterWalkSpeed, που ορίζει το Humanoid.WalkSpeed κάθε νέου χαρακτήρα. Το sprint αυτού του οδηγού προσθέτει 10, οπότε το sprint γίνεται με 26.

Πόσο γρήγορο πρέπει να είναι το sprint στο Roblox;

Τα περισσότερα παιχνίδια προσθέτουν από τη μισή έως ολόκληρη την ταχύτητα περπατήματος: το 16 γίνεται κάτι από 24 έως 32. Ένα σύντομο αργό sprint ταιριάζει σε παιχνίδι τρόμου, και ένα μακρύ γρήγορο σε μεγάλους χάρτες. Τα presets ανά είδος παιχνιδιού δίνουν για το καθένα ταχύτητα περπατήματος, μπόνους sprint και αριθμούς stamina.

Πώς φτιάχνω sprint με stamina;

Κρατάτε έναν αριθμό stamina στη συσκευή του παίκτη, τον ξοδεύετε σε κάθε καρέ κατά το sprint και τον αναπληρώνετε μετά από σύντομη ξεκούραση, και τις δύο φορές με βάση τον χρόνο του καρέ, και σταματάτε το sprint όταν φτάσει στο 0. Το MovementClient από το Βήμα 3 το κάνει αυτό με μια μπάρα στην οθόνη· οι αριθμοί βρίσκονται στο MovementConfig.

Πώς τρέχω με χειριστήριο στο Roblox;

Δέστε το ButtonL3 του gamepad (πάτημα του αριστερού μοχλού) μέσω ContextActionService μαζί με το Left Shift, όπως κάνουν και τα δύο scripts εδώ. Το ShiftToSprint κάνει το L3 διακόπτη εναλλαγής, γιατί το να κρατάτε τον μοχλό πατημένο και ταυτόχρονα να στρίβετε με αυτόν είναι κουραστικό.

Συγκρούεται το sprint με Shift με το Shift Lock;

Μπορεί. Οι παίκτες που ενεργοποίησαν το Shift Lock στις ρυθμίσεις του Roblox το εναλλάσσουν με το πλήκτρο Shift, οπότε ένα πλήκτρο κάνει δύο πράγματα. Η τεκμηρίωση της Roblox λέει ότι τα APIs του Shift Lock αποσύρονται. Αν η σύγκρουση ενοχλεί τους παίκτες σας, απενεργοποιήστε το StarterPlayer.EnableMouseLockOption ή δέστε το sprint στο MovementClient σε άλλο πλήκτρο, για παράδειγμα Left Ctrl.

Πηγές και περαιτέρω ανάγνωση

Πώς ελέγχθηκε ο κώδικας: κάθε script σε αυτή τη σελίδα περνά αυστηρό έλεγχο τύπων Luau με τους ορισμούς του Roblox API (luau-lsp, 20 Νοεμβρίου 2026). Ο έλεγχος τύπων πιάνει λάθη σε ονόματα API και λάθος τύπους, όχι όμως λάθη στη λογική του παιχνιδιού, γι' αυτό δοκιμάστε τα πάντα στο Studio πριν τη δημοσίευση.

Δοκιμάστε το RoCode στο παιχνίδι σας.

Δωρεάν credits κάθε μέρα, χωρίς κάρτα. Εγκαταστήστε το plugin, περιγράψτε μια λειτουργία και δείτε τι εμφανίζεται στο Studio.