Kurz gesagt
Leg ein LocalScript in StarterPlayerScripts, das eine Sprint-Aktion mit ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3) bindet. Solange Shift gedrückt ist, addierst du 10 zu Humanoid.WalkSpeed (aus 16 wird 26) und setzt den Wert beim Loslassen zurück. Das true fügt auf Touchscreens einen Sprint-Button hinzu, und im Skript dieses Guides schalten dieser Button und L3 am Gamepad das Sprinten an und aus, statt gehalten zu werden.
- Addiere zur aktuellen WalkSpeed, statt 26 zu setzen, damit ein Speed-Boost aus einem Game Pass erhalten bleibt.
- Sprinten läuft auf dem Gerät des Spielers. Der Server kann keine WalkSpeed erzwingen; er kann nur messen, wie weit sich Charaktere bewegen, und Tempos melden, die sich durch Sprinten nicht erklären lassen.
- Für eine Stamina-Leiste, einen Dash oder einen Doppelsprung bauen Schritt 2 bis 4 auf derselben Idee auf. Für wie schnell und wie lange liefern die Vorlagen nach Spieltyp Zahlen für Horror, Kampf und Open World.
Auf dieser Seite
So funktioniert Sprinten in Roblox
Das Gerät jedes Spielers bewegt den eigenen Charakter dieses Spielers. Tastatur, Controller oder Touchscreen entscheiden, wohin der Charakter geht, und Roblox gibt das Ergebnis an den Server und alle anderen weiter. Ein Sprint ist also ein LocalScript, das Humanoid.WalkSpeed erhöht, solange eine Taste gedrückt ist, und mehr macht Schritt 1 nicht. Der Rest dieses Guides ist das, was ein größeres Spiel drumherum braucht: eine Stamina-Leiste, einen Dash, einen Doppelsprung und eine Prüfung auf dem Server für Spieler, die cheaten.
| Teil | Wo es liegt | Was es macht |
|---|---|---|
LocalScript ShiftToSprint | StarterPlayerScripts | Schritt 1 für sich: Sprinten mit Tastatur, Handy und Gamepad, ohne Stamina. MovementClient ersetzt es, wenn du Stamina und einen Dash hinzufügst. |
ModuleScript MovementConfig | ReplicatedStorage | Die Zahlen: Sprint-Bonus, Stamina und Dash. Das LocalScript und die Server-Prüfung lesen es beide. |
LocalScript MovementClient | StarterPlayerScripts | Bindet Sprint und Dash an eine Taste, einen Gamepad-Button und einen Touch-Button, führt die Stamina-Schleife aus, zeichnet die Leiste und macht den Dash. |
LocalScript DoubleJump | StarterCharacterScripts | Gibt einen zusätzlichen Sprung in der Luft. In jedem neuen Charakter läuft eine frische Kopie. |
Script MovementCheck | ServerScriptService | Misst, wie weit sich jeder Charakter wirklich bewegt, und warnt im Output, wenn jemand dauerhaft schneller ist, als Sprint und Dash erlauben. |
ReplicatedStorage
MovementConfig ModuleScript new
ServerScriptService
MovementCheck Script new
StarterPlayer
StarterCharacterScripts
DoubleJump LocalScript new
StarterPlayerScripts
MovementClient LocalScript new
Wenn die Aufteilung zwischen Script und LocalScript neu für dich ist, erklärt Script vs LocalScript vs ModuleScript (auf Englisch), wo jede Art läuft und warum.
Schritt 1: Mit Shift sprinten in einem LocalScript
Wenn du nur schneller laufen willst, solange Shift gedrückt ist, reicht dieses eine Skript. Es gibt Handys auch einen Sprint-Button auf dem Bildschirm und lässt ein Gamepad mit dem linken Stick sprinten.
- Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts, klick auf + und füge ein LocalScript namens
ShiftToSprintein. - Ersetz seinen Inhalt durch den Code unten und drück auf Play.
-- LocalScript in StarterPlayer > StarterPlayerScripts, Name ShiftToSprint.
-- Halte Left Shift zum Sprinten. Am Gamepad klickst du den linken Stick (L3), um das
-- Sprinten an- und auszuschalten. Am Handy tippst du auf den Sprint-Button, um es an- und auszuschalten.
local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
-- Einstellungen
local SPRINT_BONUS = 10 -- wird beim Sprinten zur WalkSpeed addiert (aus 16 wird 26)
local TOGGLE_ON_TOUCH_AND_GAMEPAD = true -- false: den Button stattdessen halten
local player = Players.LocalPlayer
local sprinting = false
local normalSpeed = 16 -- die WalkSpeed, zu der zurückgekehrt wird
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
-- Aktuelles Tempo merken und darauf addieren, damit ein Speed-Boost von woanders erhalten bleibt
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
-- Halten: sprinten, solange die Taste oder der Button gedrückt ist
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
-- Umschalten: jeder Druck schaltet das Sprinten an oder aus
setSprinting(not sprinting)
end
return Enum.ContextActionResult.Pass
end
-- Ein Aufruf bindet die Taste, den Gamepad-Button und auf Touchscreens einen Button auf dem Bildschirm
ContextActionService:BindAction("Sprint", onSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.ButtonL3)
ContextActionService:SetTitle("Sprint", "Sprint")
-- Ein neuer Charakter startet gehend: Sein Humanoid hat schon die normale WalkSpeed
player.CharacterAdded:Connect(function()
sprinting = false
end)
Änder SPRINT_BONUS für einen schnelleren oder langsameren Sprint. Setz TOGGLE_ON_TOUCH_AND_GAMEPAD auf false, damit der Handy-Button und L3 wie Shift funktionieren: Sprinten nur, solange sie gehalten werden.
BindAction bindet eine Aktion an Left Shift und den L3-Button des Gamepads, und sein drittes Argument, true, fügt auf Touchscreens einen Button auf dem Bildschirm hinzu; SetTitle schreibt "Sprint" darauf. Der Handler bekommt auch die Eingabe, kann also einen Tastendruck vom Gamepad oder vom Touch-Button unterscheiden. Wenn der Sprint startet, merkt sich das Skript die aktuelle WalkSpeed und addiert SPRINT_BONUS; wenn er endet, setzt es den gemerkten Wert zurück. Ein Tempo, das ein anderes Skript setzt, etwa der Speed-Perk aus dem Game-Pass-Guide (auf Englisch), bleibt erhalten. Ein neuer Charakter startet mit seiner normalen WalkSpeed, deshalb setzt der CharacterAdded-Handler nur das Flag zurück.
Halten oder umschalten?
| Gerät und Eingabe | Funktioniert als | Warum |
|---|---|---|
| Tastatur: Left Shift | Halten | Eine Taste beim Laufen zu halten ist leicht, und Loslassen stoppt den Sprint sofort. |
| Gamepad: linken Stick klicken (L3) | Umschalten | Den Stick eingedrückt zu halten, während du mit ihm lenkst, ist anstrengend. |
| Handy oder Tablet: der Sprint-Button auf dem Bildschirm | Umschalten | Ein Daumen, der den Button hält, kann nicht gleichzeitig Springen drücken. |
Zum Testen drückst du auf Play und hältst beim Laufen Shift: Du wirst von 16 auf 26 Studs pro Sekunde schneller, und beim Loslassen wieder langsamer. Für ein Handy wählst du im Device Simulator von Studio ein Handy, drückst auf Play und tippst einmal auf Sprint zum Starten und einmal zum Stoppen. Für ein Gamepad öffnest du während des Playtests den Controller Emulator und klickst L3. Schritt 6 hat die komplette Checkliste für alle Geräte.
Schritt 2 und 3 ersetzen dieses Skript durch eines, das eine Stamina-Leiste und einen Dash hinzufügt. Schritt 4 und 5 fügen einen Doppelsprung und eine Server-Prüfung hinzu und funktionieren mit beiden Skripten.
Schritt 2: Die Zahlen für Stamina und Dash in ein Modul
Für einen Sprint, der ausgeht, tauschen Schritt 2 und 3 ShiftToSprint gegen ein größeres LocalScript mit Stamina-Leiste und Dash. Lösch ShiftToSprint vorher: Beide binden die Sprint-Aktion.
Alle Zahlen liegen in einem ModuleScript, also stellst du das Spielgefühl an einer Stelle ein. MovementClient liest sie auf dem Gerät jedes Spielers, und MovementCheck liest dasselbe Modul auf dem Server, um zu wissen, wie schnell ein Sprint und ein Dash sein sollten.
- Fahr im Explorer mit der Maus über ReplicatedStorage, klick auf + und füge ein ModuleScript ein.
- Benenn es in
MovementConfigum und ersetz seinen Inhalt durch den Code unten.
-- Ein Satz Zahlen für das Bewegungs-LocalScript und die Tempo-Prüfung auf dem Server.
local MovementConfig = {
SPRINT_BONUS = 10, -- wird zur aktuellen WalkSpeed addiert: aus 16 (Roblox-Standard) wird 26
MAX_STAMINA = 100,
DRAIN_PER_SECOND = 20, -- 5 Sekunden Sprint, wenn voll
REGEN_PER_SECOND = 15,
REGEN_DELAY = 1, -- Sekunden nach dem Sprint, bevor die Stamina zurückkommt
MIN_TO_START = 20, -- Stamina, die zum Start eines Sprints nötig ist, damit eine leere Leiste nicht an und aus flackert
DASH_SPEED = 60, -- Studs pro Sekunde während eines Dashs
DASH_SECONDS = 0.2, -- ein Dash schafft also etwa 12 Studs
DASH_COST = 25, -- Stamina
DASH_COOLDOWN = 1,
}
return MovementConfig
| Einstellung | Wert | Wirkung |
|---|---|---|
SPRINT_BONUS | 10 | Wird beim Sprinten zur WalkSpeed addiert. Die Standard-WalkSpeed von Roblox ist 16, also läuft ein Sprint mit 26 Studs pro Sekunde. |
MAX_STAMINA | 100 | Eine volle Leiste. |
DRAIN_PER_SECOND | 20 | Eine volle Leiste reicht für 5 Sekunden Sprint. |
REGEN_PER_SECOND | 15 | Eine leere Leiste braucht etwa 6,7 Sekunden, bis sie wieder voll ist. |
REGEN_DELAY | 1 | Sekunden Pause, bevor das Auffüllen beginnt. |
MIN_TO_START | 20 | Stamina, die zum Start eines Sprints nötig ist. |
DASH_SPEED | 60 | Studs pro Sekunde während eines Dashs. |
DASH_SECONDS | 0,2 | Wie lange ein Dash dauert: etwa 12 Studs bei 60 Studs pro Sekunde. |
DASH_COST | 25 | Stamina, die jeder Dash kostet. |
DASH_COOLDOWN | 1 | Sekunden zwischen zwei Dashs. |
Jede Seite führt ihre eigene Kopie eines Moduls aus (ein Modul läuft einmal pro Seite (auf Englisch)), also ändert ein Spieler, der diese Zahlen auf seinem Gerät bearbeitet, nur seine eigene Kopie. Das schützt hier allerdings nichts: Sein Gerät bewegt seinen Charakter sowieso, also kann es sich endlose Stamina geben, egal was im Modul steht. Die Server-Prüfung in Schritt 5 ist genau darauf ausgelegt.
Schritt 3: Sprint mit Stamina und Dash
Dieses LocalScript macht die Arbeit, die Spieler spüren. Es bindet Sprint und Dash, zeichnet die Stamina-Leiste, führt die Stamina-Schleife in jedem Frame aus und macht den Dash.
- Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts und füge ein LocalScript namens
MovementClientein. - Ersetz seinen Inhalt durch den Code unten.
-- Halte Shift (oder L3, oder den Sprint-Button am Handy), um zu sprinten, solange die Stamina reicht.
-- Drück Q (oder B, oder den Dash-Button) für einen Dash in die Richtung, in die du läufst.
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 -- die WalkSpeed, zu der zurückgekehrt wird, wenn der Sprint endet
local lastSprintTime = 0
local lastDashTime = -math.huge
-- Stamina-Leiste: ein Frame mit einer Füllung, deren Breite die restliche Stamina ist
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: hier nur ein Flag; die Heartbeat-Schleife unten entscheidet in jedem Frame, ob gesprintet wird
local function onSprint(_name: string, state: Enum.UserInputState, _input: InputObject): Enum.ContextActionResult
-- Nur Drücken oder Loslassen ändert es: Ein Finger, der über den Touch-Button rutscht, sendet 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()
-- Kein Dash im Sitzen: Ein sitzender Charakter ist an seinen Sitz geschweißt, also würde er das ganze Fahrzeug schieben
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 -- das Auffüllen pausieren, wie beim Sprinten
-- Dash in die Laufrichtung, oder in Blickrichtung, wenn der Spieler steht
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 im Plane-Modus hält das waagerechte Tempo und lässt die Schwerkraft in Ruhe
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
-- Je ein Aufruf bindet eine Taste, einen Gamepad-Button und auf Touch-Geräten einen Button auf dem Bildschirm
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")
-- In jedem Frame: Stamina beim Sprinten und Laufen abziehen, nach einer kurzen Pause auffüllen
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 nur ändern, wenn ein Sprint startet oder endet, damit ein Tempo, das ein
-- anderes Skript setzt (etwa ein Speed Pass), erhalten bleibt und der Sprint darauf addiert
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)
-- Ein neuer Charakter startet mit voller Stamina und ohne gehaltene Taste
player.CharacterAdded:Connect(function()
stamina = Config.MAX_STAMINA
sprintHeld = false
sprinting = false -- der neue Humanoid startet mit seiner normalen WalkSpeed
end)
Die Stamina-Leiste wird im Code gebaut, mit ResetOnSpawn auf false, also bleibt sie über Respawns hinweg auf dem Bildschirm, und der CharacterAdded-Handler ganz unten füllt sie für jeden neuen Charakter wieder auf. Die Zeilen mit type Config beschreiben, was das Modul zurückgibt, damit die strikte Typprüfung eine falsch geschriebene Einstellung findet; im laufenden Spiel ändern sie nichts.
Tastatur, Gamepad und ein Handy-Button mit einem Aufruf
ContextActionService:BindAction nimmt einen Aktionsnamen, eine Handler-Funktion, ob ein Touch-Button erstellt werden soll, und dann die Eingaben. Mit true als drittem Argument fügt ContextActionService auf Geräten mit Touch einen Button auf dem Bildschirm hinzu, in einer ScreenGui namens ContextActionGui im PlayerGui des Spielers. SetTitle schreibt "Sprint" und "Dash" auf diese Buttons. BindAction kann höchstens 7 Touch-Buttons erstellen, also zähl mit, wenn andere Skripte in deinem Spiel sie auch nutzen.
Der Handler bekommt den Zustand der Eingabe: Begin beim Drücken und End beim Loslassen. onSprint merkt sich nur, ob Sprint gehalten wird. Es behandelt auch Cancel als Loslassen, das ContextActionService schickt, wenn eine andere Bindung die Eingabe übernimmt, und ignoriert Change, das ein Finger senden kann, der sich auf dem Touch-Button bewegt. Beide Handler geben Pass zurück, also bekommt die nächste Bindung auf derselben Taste die Eingabe trotzdem.
Die ContextActionService-Referenz von Roblox empfiehlt den Dienst für die meisten Fälle statt UserInputService.InputBegan. Ihr Beispiel ist eine Autohupe auf H, die nicht hupen soll, während der Spieler im Chat tippt: Eine Bindung feuert nur, solange sie die neueste für diese Eingabe ist, also musst du nichts prüfen, wenn das Chatfeld die Tastatur übernimmt. Die Gamepad-Eingaben sind ButtonL3 (den linken Stick eindrücken, beim Laufen gehalten) und ButtonB. Das Sprint-Beispiel von Roblox selbst nutzt ButtonY, also änder den KeyCode in BindAction, wenn das besser zu deinem Spiel passt.
Die Stamina-Schleife
RunService.Heartbeat feuert in jedem Frame nach dem Physik-Schritt und übergibt deltaTime, die Sekunden seit dem vorigen Frame. Wenn du die Abzugs- und Auffüllraten damit multiplizierst, reicht eine volle Leiste 5 Sekunden, egal ob das Spiel mit 30 oder 240 Bildern pro Sekunde läuft.
In jedem Frame entscheidet die Schleife, ob der Charakter sprinten soll: Sprint wird gehalten, der Charakter läuft (Humanoid.MoveDirection ist ein Nullvektor, wenn nicht), und es ist noch Stamina übrig. Um einen Sprint zu starten, braucht es mindestens MIN_TO_START (20); um ihn fortzusetzen, reicht alles über 0. Ohne diesen Abstand würde eine leere Leiste, die sich in jedem Frame ein winziges Stück füllt, den Sprint in jedem Frame an- und ausschalten. Das Auffüllen beginnt REGEN_DELAY (1 Sekunde) nach dem letzten Sprint oder Dash, also wartet ein Spieler, der die Leiste leer gelaufen hat, etwa 2,3 Sekunden, bevor er wieder sprinten kann.
WalkSpeed ändert sich nur in dem Frame, in dem ein Sprint startet oder endet. Beim Start merkt sich das Skript die aktuelle WalkSpeed und addiert SPRINT_BONUS; beim Ende setzt es den gemerkten Wert zurück. Deshalb übersteht ein Tempo, das ein anderes Skript setzt: Der Speed-Perk aus dem Game-Pass-Guide (auf Englisch) setzt die WalkSpeed auf 24, und mit diesem Skript sprinten seine Besitzer mit 34. Ein Skript, das in jedem Frame oder bei jedem Loslassen WalkSpeed = 16 schreibt, würde diesen Perk still aufheben.
Der Dash
Der Dash schiebt den Charakter in seine Laufrichtung, oder in seine Blickrichtung, wenn er steht, flach gemacht, damit er nie nach oben oder unten zeigt. Er kostet 25 Stamina, pausiert das Auffüllen wie ein Sprint und hat 1 Sekunde Cooldown. Nichts darin prüft den Boden, also funktioniert er auch in der Luft, was gut zum Doppelsprung passt. Im Sitzen macht er nichts: Ein sitzender Charakter ist an seinen Sitz geschweißt, also könnte der Schub in einem Fahrzeug das ganze Fahrzeug schieben.
Der Schub ist ein LinearVelocity-Constraint am RootAttachment des Root-Parts. Im Plane-Modus mit den Achsen X und Z hält er das waagerechte Tempo bei 60 Studs pro Sekunde und lässt die senkrechte Richtung in Ruhe, also wirkt die Schwerkraft weiter und ein Dash über eine Kante fällt ganz normal. MaxForce ist math.huge, also ist der Schub nicht begrenzt. Debris:AddItem zerstört den Constraint nach DASH_SECONDS, ohne dass das Skript warten muss, also dauert der Dash 0,2 Sekunden, etwa 12 Studs bei diesem Tempo.
Ältere Tutorials nutzen BodyVelocity, das Roblox als veraltet markiert, mit dem Hinweis, stattdessen LinearVelocity zu nutzen. Sein Trick, MaxForce auf einer Achse auf null zu setzen, wird durch die Modi Line, Plane und Vector von LinearVelocity ersetzt. Weil das Gerät des Spielers seinen eigenen Charakter simuliert, bewegt ihn der Constraint, den das LocalScript erstellt, und andere Spieler sehen den Dash wie jede andere Bewegung.
Das UI-Tutorial von Roblox selbst hängt einen Constraint genauso an humanoid.RootPart.RootAttachment. Wenn dein Spiel einen eigenen Charakter nutzt, dessen Root-Part kein Attachment namens RootAttachment hat, macht der Dash nichts: Füg eines zum HumanoidRootPart deines StarterCharacter hinzu.
Schritt 4: Einen Doppelsprung hinzufügen
Der Doppelsprung lebt in einem eigenen LocalScript in StarterCharacterScripts. Roblox legt eine Kopie der Skripte aus diesem Container in jeden Charakter, wenn er spawnt, und diese Kopien überleben keinen Respawn, also startet jedes Leben mit einem frischen Skript, und nichts wird vom letzten übernommen.
- Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterCharacterScripts und füge ein LocalScript namens
DoubleJumpein. - Ersetz seinen Inhalt durch den Code unten.
-- Gibt einen zusätzlichen Sprung in der Luft. Es läuft für jeden neuen Charakter neu,
-- also wird nach einem Respawn nichts übernommen.
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 feuert für einen Druck mehrmals
local NEW_PRESS_GAP = 0.1 -- ein gehaltener Sprung-Button feuert JumpRequest immer weiter; eine so lange Pause heißt, er wurde losgelassen
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
-- Ein Sprung vom Boden (keiner unserer Luftsprünge) füllt die Luftsprünge wieder auf
jumpsLeft = EXTRA_JUMPS
lastJump = os.clock()
elseif newState == Enum.HumanoidStateType.Landed then
jumpsLeft = 0
end
end)
-- JumpRequest feuert immer, wenn der Spieler springen will, etwa mit der Leertaste oder dem Sprung-Button am Handy
UserInputService.JumpRequest:Connect(function()
local now = os.clock()
local newPress = now - lastRequest > NEW_PRESS_GAP
lastRequest = now
-- Nur ein frischer Druck springt noch einmal, also verbraucht ein gehaltener Button den Luftsprung nicht
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)
Setz EXTRA_JUMPS auf 2 für einen Dreifachsprung.
Das Skript verfolgt den Zustand des Charakters mit Humanoid.StateChanged. Ein Wechsel zu Jumping, der nicht von Freefall kommt, ist ein Sprung vom Boden, also vergibt es den Luftsprung, und Landed nimmt ihn wieder weg. Von einer Kante zu laufen geht ohne Sprung in Freefall, gibt also keinen Luftsprung. Wenn du dort auch einen willst, setz jumpsLeft zusätzlich, wenn der Zustand von etwas anderem als Jumping zu Freefall wechselt.
UserInputService.JumpRequest feuert, wenn der Spieler springen will, zum Beispiel mit der Leertaste oder dem Sprung-Button am Handy. Die Referenz von Roblox warnt, dass es für eine einzige Sprunganfrage mehrmals feuert, und empfiehlt ein Debounce, also ignoriert das Skript Anfragen innerhalb von 0,25 Sekunden nach dem letzten Sprung. Ein gehaltener Sprung-Button kann auch immer weiter Sprünge anfragen, was den Luftsprung in dem Moment verbrauchen würde, in dem der Charakter den Boden verlässt, also zählt eine Anfrage erst nach 0,1 Sekunden ohne Anfrage als neuer Druck.
Der Luftsprung selbst ist Humanoid:ChangeState(Enum.HumanoidStateType.Jumping). Die Referenz von Roblox sagt, dass er aus einem LocalScript auf einem Gerät aufgerufen werden muss, das die Network Ownership über den Charakter hat, standardmäßig das eigene Gerät des Spielers, nicht der Server. Ihr Codebeispiel für ChangeState ist ein Doppelsprung.
Schritt 5: Speed-Exploits auf dem Server melden
Sprint-Tutorials hören oft beim Client auf. Ein Server-Script kann der WalkSpeed eines Spielers nicht trauen, weil Exploiter sie auf ihrem eigenen Gerät ändern, aber es sieht, wo ihr Charakter landet. MovementCheck misst das zweimal pro Sekunde und warnt im Output, wenn jemand dauerhaft schneller ist, als Sprint und Dash erlauben. Es liest die Sprint- und Dash-Zahlen aus MovementConfig, also füg dieses Modul aus Schritt 2 hinzu, auch wenn du ShiftToSprint behalten hast.
- Fahr mit der Maus über ServerScriptService und füge ein Script namens
MovementCheckein. - Ersetz seinen Inhalt durch den Code unten.
-- Die Geräte der Spieler bewegen ihre eigenen Charaktere, also kann ein Exploiter jede WalkSpeed setzen.
-- Diese Prüfung misst, wie weit sich jeder Charakter wirklich bewegt, und warnt im Output,
-- wenn jemand dauerhaft schneller ist, als Sprint und Dash erlauben. Sie warnt nur:
-- Lag, Teleports und Förderbänder können alle wie Rasen aussehen, also stell sie ein, bevor du jemanden bestrafst.
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 -- Sekunden
-- Sprint-Tempo plus Spielraum für Lag. Erhöh es, wenn du Speed-Boosts verkaufst.
local SPEED_ALLOWANCE = (StarterPlayer.CharacterWalkSpeed + Config.SPRINT_BONUS) * 1.25
local BURST_ALLOWANCE = Config.DASH_SPEED * Config.DASH_SECONDS * 2 -- Spielraum für einen oder zwei Dashs
local DRAIN_PER_CHECK = BURST_ALLOWANCE / 8 -- wie schnell vergangene Schübe vergeben werden
local lastPosition: { [Player]: Vector3 } = {}
local lastRoot: { [Player]: BasePart } = {} -- der Root-Part, an dem lastPosition gemessen wurde
local excess: { [Player]: number } = {} -- Studs über dem Spielraum, langsam vergeben
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
-- Ein Respawn ist ein neuer Root-Part, und ein Teleport vom Server (Rundenstart, Checkpoint)
-- setzt das Attribut unten: neu messen, statt den Sprung zu melden
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
-- Nur waagerechte Bewegung: schnell fallen ist kein Cheaten
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
Die Warnung erscheint im Output von Studio. In einem Live-Spiel landet sie im Server-Log der Developer Console, das du als Besitzer des Spiels lesen kannst: siehe Output in einem Live-Spiel.
Was es misst
Jede halbe Sekunde liest das Skript die Position des Root-Parts jedes Charakters und misst, wie weit er sich seit der letzten Prüfung seitlich bewegt hat. Die Höhe wird ignoriert, also zählen Fallen und Springen nie; die Hinweise von Roblox zur Bewegungsprüfung empfehlen dieselbe Projektion auf die XZ-Ebene für Spiele am Boden. Der Spielraum ist das Standard-Lauftempo plus der Sprint-Bonus, plus ein Viertel für Lag: 32,5 Studs pro Sekunde. Strecke darüber hinaus kommt in einen Leaky Bucket, eine Art Sammelbehälter, mit dem laut der Doku von Roblox viele Entwickler bei kurzen Bewegungsschüben gute Erfahrungen machen. Der Bucket verliert bei jeder Prüfung 3 Studs, und das Skript warnt, wenn er mehr als 24 Studs enthält, was Platz für etwa zwei Dashs ist.
| Ein Cheater, der | Was MovementCheck macht |
|---|---|
| die WalkSpeed auf 100 setzt | Warnt nach etwa einer Sekunde Laufen |
| die WalkSpeed auf 50 setzt | Warnt nach etwa 2,5 Sekunden Laufen |
| Dashs ohne Cooldown aneinanderreiht (60 Studs pro Sekunde) | Warnt nach etwa 1,5 Sekunden |
| sich mehr als etwa 43 Studs auf einmal teleportiert | Warnt bei der nächsten Prüfung |
| mit bis zu 38 Studs pro Sekunde läuft, etwa dem Anderthalbfachen des Sprint-Tempos | Nichts: Unter 38,5 Studs pro Sekunde leert sich der Bucket so schnell, wie er sich füllt |
| seine eigene MovementConfig für endlose Stamina bearbeitet | Nichts: Ein Sprint mit 26 Studs pro Sekunde ist erlaubt, egal wie lange er dauert |
| fliegt, ohne Grenze springt oder durch Wände geht | Nichts: Die Prüfung ignoriert die Höhe und schaut sich keine Kollisionen an |
Die Prüfung erwischt also die groben Cheats, die einen Spieler deutlich schneller machen als alle anderen, und übersieht vorsichtige. Das ist die ehrliche Grenze einer Distanzprüfung, und der Grund, warum Roblox etwas Stärkeres baut (siehe Server Authority unten).
Warum es nur warnt
Die Doku von Roblox weist darauf hin, dass einfache Tempo-Prüfungen unschuldige Spieler mit instabiler Verbindung melden können und in Spielen mit Fahrzeugen oder anderer komplexer Bewegung versagen. Lag-Spitzen, Förderbänder, Fahrzeuge, Explosionen, die Charaktere wegschleudern, und deine eigenen Teleports können alle wie Rasen aussehen, also gibt das Skript nur eine Warnung aus. Beobachte den Output, während du und deine Tester normal spielen, erhöh SPEED_ALLOWANCE, wenn ehrliche Spieler sie auslösen, und füg eine Strafe, etwa den Spieler zurückzusetzen, erst hinzu, wenn die Prüfung beim normalen Spielen still bleibt. Wenn Explosionen in deinem Spiel Charaktere wegschleudern, überspring auch Spieler, deren Humanoid keine Health mehr hat.
Respawns und Teleports
Ein Respawn erstellt einen neuen Root-Part, und das Skript fängt neu an zu messen, wenn es einen sieht, also zählt Sterben weit weg vom Spawnpunkt nie als Rasen. Teleports, die deine eigenen Server-Skripte machen, brauchen eine Ausnahme, wie die Doku von Roblox für jedes Spiel mit Teleport-Mechaniken sagt. Füg nach dem Teleport player:SetAttribute("MovementCheckSkip", true) hinzu, dann misst die nächste Prüfung ab der neuen Position, statt den Sprung zu melden:
- Im Rundensystem direkt nach
character:PivotTo(...)instartRound. - Im Obby-Checkpoint-Skript (auf Englisch) direkt nach jedem
character:PivotTo(...), das einen Spieler zu seinem Checkpoint bringt.
Die Pads und das Menü aus dem Teleporter-Guide und das Finish-Pad im Guide zum ersten Spiel setzen es schon nach jeder Bewegung.
Nur der Wert des Servers zählt. Ein Attribut, das ein Spieler auf seinem eigenen Gerät setzt, bleibt auf diesem Gerät (siehe was repliziert wird und was nicht (auf Englisch)), also kann ein Cheater die Prüfung damit nicht ausschalten.
Die langfristige Lösung: Server Authority
Die Sicherheits-Doku von Roblox nennt das Modell Server Authority, beim Schreiben dieses Guides in der Beta, den zuverlässigsten Weg, Bewegungs-Exploits zu stoppen. Der Server wird zur maßgeblichen Quelle, und die Geräte der Spieler melden nur ihre Eingaben, was laut der Doku Speed-Hacks verhindert, weil einem Gerät nie zugetraut wird, seine eigene Position zu melden.
Der Wechsel ist ein Umschreiben, keine Einstellung. In diesem Modell führt der Server die Bewegung aus, also wird eine WalkSpeed oder LinearVelocity, die nur ein LocalScript setzt, rückgängig gemacht, wenn der Zustand vom Server ankommt. Die Doku von Roblox sagt, dass die Kernlogik in RunService:BindToSimulation()-Funktionen in einem ModuleScript laufen muss, das Client und Server beide ausführen. Das Modell braucht außerdem mehrere Workspace-Einstellungen, darunter PlayerScriptsUseInputActionSystem, also würden deine Steuerungen auch zum Input Action System umziehen. Behalt die Version aus diesem Guide, bis du Sprint, Stamina und Dash in dieses Setup verschiebst. Bis dahin ist eine Distanzprüfung wie diese genau das, was der Abschnitt zur Bewegungsprüfung von Roblox beschreibt.
Schritt 6: Auf jedem Gerät testen
- Drück auf Play und halte beim Laufen Shift. Du wirst von 16 auf 26 Studs pro Sekunde schneller, und die grüne Leiste unten am Bildschirm schrumpft. Nach etwa 5 Sekunden ist sie leer, und du fällst auf Lauftempo zurück.
- Lass Shift los. Nach 1 Sekunde beginnt die Leiste sich wieder zu füllen. Bis sie zu einem Fünftel voll ist, macht Shift halten nichts.
- Drück beim Laufen Q: Du schießt ein Stück nach vorn, und ein Viertel der Leiste ist weg. Drück sofort noch einmal Q, und nichts passiert, bis eine Sekunde vergangen ist. Wenn der Dash zu kurz oder zu lang wirkt, änder
DASH_SPEEDoderDASH_SECONDSin MovementConfig. - Spring, und drück in der Luft noch einmal Springen für einen zweiten Sprung. Lande und versuch es wieder: Jeder Sprung vom Boden gibt den Luftsprung zurück.
- Halte die Leertaste einen ganzen Sprung lang gedrückt. Du solltest einen Sprung bekommen, nicht zwei, weil der Luftsprung einen frischen Druck braucht.
- Schalte den Device Simulator von Studio ein (beim Schreiben dieses Guides eine Beta: File, Beta Features, New Device Simulator, dann Studio neu starten), oder schalte den älteren Device Emulator über das Menü Test ein. Wähl ein Handy und drück auf Play. Sprint- und Dash-Buttons erscheinen. Halte Sprint, während du lenkst, halte dann den Sprung-Button einen ganzen Sprung lang und prüf, dass du nur einen Sprung bekommst.
- Öffne den Controller Emulator (Controller im Tab Emulation, oder Virtual controller in der Toolbar des Device Simulator). Halte L3 beim Laufen zum Sprinten, drück B für einen Dash und zweimal A für den Doppelsprung.
- Setz deinen Charakter über das Menü im Spiel zurück. Die Leiste ist wieder voll, der Output zeigt keine MovementCheck-Warnung, und wenn du noch ein Handy simulierst, sind die Sprint- und Dash-Buttons noch da.
- Jetzt spielst du den Cheater. Klick auf den Schalter Client/Server, bis der Explorer den Client zeigt, wähl unter Workspace den Humanoid deines Charakters aus und setz im Properties-Fenster WalkSpeed auf 60. Lauf ein paar Sekunden: Der Output zeigt eine Warnung wie
MovementCheck: YourName moved 60 studs/s. Setz den Wert zurück auf 16, sprinte und dashe dann eine Minute lang normal und prüf, dass der Output still bleibt. - Wenn in deinem Place
Workspace.PlayerScriptsUseInputActionSystemauf Enabled steht, teste den Doppelsprung noch einmal: Die Doku von Roblox sagt nicht, ob sichJumpRequestdamit genauso verhält.
Wenn gar nichts passiert, öffne das Output-Fenster über das Menü Window von Studio und such nach einem roten Fehler von MovementClient, oder schau unter Häufige Fehler.
Wie schnell und wie lange: Vorlagen nach Spieltyp
Der richtige Sprint hängt vom Spiel ab. Eine Horror-Verfolgung will einen kurzen, langsamen Sprint, der im schlechtesten Moment ausgeht; eine große offene Map will einen langen, damit Spieler sich beim Durchqueren nicht langweilen. Diese Vorlagen nutzen dieselben Skripte und ändern nur das Lauftempo und MovementConfig. Es sind unsere Startwerte, aus den Einstellungen berechnet, nicht an Spielern gemessen.
| Spieltyp | CharacterWalkSpeed | SPRINT_BONUS (Sprint-Tempo) | DRAIN_PER_SECOND | REGEN_PER_SECOND | Voller Sprint | Leer bis voll | Strecke mit einer Leiste |
|---|---|---|---|---|---|---|---|
| Dieser Guide | 16 | 10 (26) | 20 | 15 | 5 s | 7,7 s | 130 Studs |
| Horror-Verfolgung | 12 | 8 (20) | 25 | 10 | 4 s | 11 s | 80 Studs |
| Battlegrounds und Kampf | 16 | 12 (28) | 15 | 20 | 6,7 s | 6 s | etwa 187 Studs |
| Open World oder Simulator | 16 | 16 (32) | 10 | 25 | 10 s | 5 s | 320 Studs |
| Obby oder Parkour | 16 | 8 (24) | keine Stamina: nimm ShiftToSprint |
- Das Lauftempo steht in StarterPlayer. Wähl StarterPlayer aus und setz
CharacterWalkSpeed(standardmäßig 16). Jeder neue Charakter startet mit diesem Tempo, der Sprint addiertSPRINT_BONUSdarauf, und MovementCheck liest es auch, also folgt die Server-Prüfung deiner Wahl. - MovementCheck passt sich an. Es erlaubt das Lauftempo plus den Sprint-Bonus, plus ein Viertel für Lag: 25 Studs pro Sekunde bei der Horror-Vorlage, 40 bei der Open-World-Vorlage. Sonst musst du nichts ändern.
- In einem Obby verändert Sprinten den Parcours. Schnelleres Laufen schafft längere Lücken. Bau die Sprünge, dann teste jeden einzelnen mit Sprint-Tempo, sonst macht ein Sprint die Stages zu leicht. Der Guide zu Obby-Checkpoints (auf Englisch) passt gut zu ShiftToSprint.
- In einem Horrorspiel ist der Killer der Maßstab. Mach den Verfolger etwas schneller als das Lauftempo und etwas langsamer als den Sprint, damit die Flucht davon abhängt, wann die Leiste ausgeht. Der Guide zum Horrorspiel behandelt den Rest der Spielschleife.
Was ältere Sprint-Skripte falsch machen
Ältere Tutorials für Sprint, Dash und Doppelsprung laufen oft noch, aber viele nutzen Muster, die Roblox inzwischen ersetzt hat, oder machen andere Systeme in deinem Spiel kaputt. Wenn du ein kopiertes Skript reparierst, prüf es mit dieser Liste.
| Muster | Warum es ein Problem ist | Dieser Guide |
|---|---|---|
BodyVelocity für einen Dash | Veraltet: Roblox sagt, stattdessen LinearVelocity zu nutzen | LinearVelocity im Plane-Modus |
Eine Schleife auf RunService.RenderStepped | Für neue Arbeit durch PreRender ersetzt. Spiellogik wie Stamina gehört auf Heartbeat, das Roblox für regelmäßige Aufgaben wie Health-Regeneration beschreibt | Heartbeat mit deltaTime |
Eine Stamina-Schleife mit wait() | wait() ist zugunsten von task.wait() veraltet und wird gedrosselt, kann also länger warten als verlangt, und ein fester Betrag pro Warten zieht ungleichmäßig ab | Abzug und Auffüllen in jedem Frame mit deltaTime skaliert |
UserInputService.InputBegan ohne Prüfung auf den Chat | Shift beim Tippen einer Chatnachricht startet einen Sprint | ContextActionService, das auch den Handy-Button hinzufügt |
WalkSpeed = 16 beim Loslassen oder in jedem Frame setzen | Überschreibt jedes andere Tempo, etwa einen Game-Pass-Perk | Ändert die WalkSpeed nur, wenn ein Sprint startet oder endet, und addiert auf den aktuellen Wert |
| Sprinten über ein RemoteEvent, damit der Server die WalkSpeed setzt | Exploiter setzen ihre eigene WalkSpeed trotzdem, und der Sprint startet einen Hin- und Rückweg zu spät | Sprint auf dem Client, plus eine Distanzprüfung auf dem Server |
Ein Doppelsprung bei jedem JumpRequest | JumpRequest feuert für eine Sprunganfrage mehrmals, und ein gehaltener Button kann immer weiter Sprünge anfragen | Eine Lücke von 0,25 Sekunden und eine Prüfung auf frischen Druck |
UserInputService.TouchEnabled als "ist es Mobil?"-Prüfung | Es ist true auf Laptops mit Touchscreen | ContextActionService fügt die Buttons auf Geräten mit Touch hinzu, ohne eigene Geräteprüfung |
Humanoid:LoadAnimation für eine Laufanimation | Veraltet zugunsten von Animator:LoadAnimation | Die Laufanimation unten nutzt den Animator |
Der neuere Weg von Roblox: das Input Action System
Die Seite zum Input Action System von Roblox nutzt einen Charakter-Sprint als erstes Beispiel. Statt BindAction-Aufrufen richtest du die Steuerung in Studio ein: eine InputAction namens CharacterSprint in einem Input Context in ReplicatedStorage, mit einem InputBinding für Left Shift, einem für den Y-Button des Gamepads und einem, das mit einem Button auf dem Bildschirm verknüpft ist, den du in StarterGui gestaltest. Ein Client-Skript hört dann auf die Events Pressed und Released der Aktion, verdoppelt die WalkSpeed beim Drücken und setzt sie beim Loslassen zurück.
Der Wechsel lohnt sich, wenn du die Steuerung lieber in Studio als im Code anlegst, einen eigenen Touch-Button statt dem von ContextActionService willst, oder Contexts, die ganze Steuerungssätze austauschen, etwa für ein Menü oder ein Fahrzeug. Die Seite empfiehlt auch, Workspace.PlayerScriptsUseInputActionSystem auf Enabled zu setzen, und Server Authority setzt es voraus.
Die Stamina-Schleife und der Dash aus diesem Guide funktionieren mit dem Input Action System allein (ohne Server Authority) genauso. Behalt MovementConfig, die Heartbeat-Schleife und dash(), lösch die beiden BindAction-Aufrufe und ihre Handler und verbinde stattdessen die Aktionen: Pressed der Sprint-Aktion setzt sprintHeld auf true und ihr Released auf false, und Pressed der Dash-Aktion ruft dash() auf. Such den Humanoid weiter in jedem Frame, wie MovementClient es tut, denn das Beispiel in der Doku speichert den Humanoid des ersten Charakters, der nach einem Respawn weg ist.
Roblox testet außerdem eine Character Controller Library, eine Beta, die du in Studio unter Beta Features und Avatar Settings einschaltest. Ihre Seite zu Custom Abilities baut als Beispiel einen Dash, mit einem aktiven Fenster von 0,2 Sekunden und 1 Sekunde Cooldown, dasselbe Timing wie der Dash in diesem Guide.
Erweitern: Animation, Kamera und ein Sprint-Pass
Eine Laufanimation
Erstell im Animation Editor eine Laufanimation, setz ihre Priority auf Movement (die Priority, die Roblox für Geh- und Laufanimationen empfiehlt), veröffentliche sie und kopier ihre Asset-ID. Erstell in MovementClient eine Animation mit dieser AnimationId, lade sie mit Animator:LoadAnimation über den Animator im Humanoid des Charakters, spiel den Track dort ab, wo ein Sprint startet, und stopp ihn dort, wo der Sprint endet. Lade sie für jeden neuen Charakter neu.
Animationen, die dein Gerät an deinem eigenen Charakter startet, sehen alle, solange du den Animator nutzt, den Roblox dort angelegt hat: Tracks, die auf einem Animator geladen werden, den ein LocalScript erstellt hat, werden nicht repliziert. Humanoid:LoadAnimation, das viele ältere Tutorials nutzen, ist veraltet.
Die Kamera beim Sprinten weiten
Ein etwas weiteres Sichtfeld lässt einen Sprint schneller wirken. Tweene an denselben zwei Stellen workspace.CurrentCamera.FieldOfView von seinem Standardwert 70 auf etwa 80, wenn ein Sprint startet, und zurück, wenn er endet, zum Beispiel mit TweenService:Create(workspace.CurrentCamera, TweenInfo.new(0.25), { FieldOfView = 80 }):Play(). Roblox begrenzt den Wert auf 1 bis 120 und warnt, dass sehr niedrige oder sehr hohe Werte Spieler desorientieren können. Wenn ein anderes Skript in deinem Spiel das Sichtfeld auch ändert, tweene zurück zu dem Wert, den du vorgefunden hast, statt zu 70.
Ein schnellerer Sprint als Game Pass
Der Guide zu Game Passes (auf Englisch) funktioniert schon mit diesem Skript: Sein Speed-Perk setzt die WalkSpeed für jeden neuen Charakter auf dem Server auf 24, MovementClient addiert den Sprint-Bonus obendrauf, und 34 Studs pro Sekunde bleiben innerhalb dessen, was MovementCheck erlaubt.
Für einen Pass, der den Sprint selbst schneller macht, füg einen FastSprint-Pass zu PassConfig.ids aus diesem Guide hinzu. Sein Server-Script setzt dann das Attribut OwnsPass_FastSprint am Spieler, sobald der Pass bestätigt ist. Nimm in MovementClient einen größeren Bonus als Config.SPRINT_BONUS, wenn player:GetAttribute("OwnsPass_FastSprint") == true gilt. Gib diesen Spielern in MovementCheck einen größeren Spielraum, indem du dasselbe Attribut auf dem Server liest, wo ein Spieler es nicht ändern kann, und prüf, dass das neue Höchsttempo unter dem bleibt, was die Prüfung meldet.
Eine Grenze solltest du kennen: Wenn ein anderes Skript die WalkSpeed mitten in einem Sprint ändert, setzt das Ende dieses Sprints das Tempo von vor dem Sprint zurück. Der nächste Respawn setzt das Pass-Tempo wieder, weil das Game-Pass-Skript es auf jeden neuen Charakter anwendet.
Häufige Fehler und Lösungen
Öffne das Output-Fenster (Menü Window, dann Output), bevor du auf Play drückst. Die meisten Probleme mit diesen Skripten geben dort einen Fehler oder eine Warnung aus, mit dem Namen des Skripts und der Zeile.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("MovementConfig")'
MovementClient oder MovementCheck wartet auf ein Modul, das es unter genau diesem Namen nicht gibt. Es muss ein ModuleScript namens MovementConfig direkt in ReplicatedStorage sein. Der Guide zu Skriptfehlern erklärt diese Warnung im Detail.
Shift halten macht nichts
Prüf, dass ShiftToSprint oder MovementClient ein LocalScript ist, kein Script, und in StarterPlayerScripts liegt. Mit MovementClient braucht ein Sprint außerdem einen laufenden Charakter und mindestens 20 Stamina zum Start, also halte Shift, während du dich bewegst. Wenn stattdessen Shift Lock umschaltet, sieh dir die Frage zu Shift Lock unten an.
Der Sprint hört nach ein paar Sekunden auf
Das ist die Stamina, die ausgeht: 100 Stamina bei 20 pro Sekunde reichen 5 Sekunden. Erhöh MAX_STAMINA oder senk DRAIN_PER_SECOND in MovementConfig.
Der Dash macht nichts
Ein Dash braucht 25 Stamina, wartet 1 Sekunde nach dem letzten und macht im Sitzen nichts. Wenn es daran nicht liegt, hat der Root-Part deines Charakters vielleicht kein Attachment namens RootAttachment, was bei manchen eigenen Charakteren vorkommt: Füg eines zum HumanoidRootPart deines StarterCharacter hinzu.
Der Doppelsprung passiert nie
DoubleJump muss ein LocalScript in StarterCharacterScripts sein, nicht in StarterPlayerScripts, weil es script.Parent als Charakter liest. Drück Springen ein zweites Mal, nachdem du den Boden verlassen hast: Den Button zu halten zählt nicht als neuer Druck, und von einer Kante zu laufen gibt keinen Luftsprung.
Am Handy gibt es keinen Sprint- oder Dash-Button
ContextActionService fügt seine Buttons nur auf Geräten mit Touch hinzu, also erscheinen sie nie auf einem PC ohne Touchscreen. Teste mit einem Handy im Device Simulator von Studio (eine Beta: Schalte New Device Simulator unter File, Beta Features ein und starte Studio neu). BindAction kann höchstens 7 Touch-Buttons erstellen, also zähl, wie viele andere Skripte in deinem Spiel welche erstellen.
MovementCheck warnt bei ehrlichen Spielern
Die üblichen Ursachen sind ein Teleport durch ein anderes Server-Skript, ein Förderband oder Fahrzeug, oder Lag. Setz das Attribut MovementCheckSkip nach deinen eigenen Teleports (siehe Respawns und Teleports), und erhöh SPEED_ALLOWANCE, wenn es beim normalen Spielen weiter feuert.
Ein Speed-Boost geht nach dem Sprinten verloren
Ein anderes Skript hat die WalkSpeed während des Sprints geändert, und der Sprint hat zum Schluss das Tempo zurückgesetzt, das er beim Start gesehen hat. Wende Speed-Boosts an, wenn der Charakter spawnt, wie es der Game-Pass-Guide macht, damit ein Respawn wieder das richtige Tempo setzt.
Mit RoCode bauen
Wenn du das nicht von Hand einrichten willst, kann RoCode es in dem Place bauen, den du offen hast. RoCode ist ein unabhängiger KI-Agent für Roblox Studio und stammt nicht von Roblox: Du beschreibst die Änderung in einem Webchat, und sein Studio-Plugin erstellt die Skripte in deinem Explorer, also gibt es keinen Code zum Einfügen.
Füg Shift to Sprint mit einer Stamina-Leiste hinzu: Lauftempo plus 10, solange Shift gehalten wird, 100 Stamina, die um 20 pro Sekunde sinkt und sich nach einer Sekunde Pause um 15 pro Sekunde wieder füllt, ein Sprint-Button am Handy, Q für einen Dash, und ein Doppelsprung.
- Kann zuerst mit Search Scripts und Read Script deinen Place lesen, um andere Skripte zu finden, die die WalkSpeed ändern (etwa einen Game-Pass-Perk), damit der Sprint darauf addiert
- Schreibt das ModuleScript, die LocalScripts und die Server-Prüfung mit Create Script
- Ist angewiesen, jedes Skript, das es schreibt, mit Check Script auf Kompilierfehler zu prüfen; das kompiliert es in Studio, ohne es auszuführen
- Setzt vor und nach jeder Änderungsrunde einen Undo-Punkt, sodass Strg+Z jeweils eine Runde zurückgeht
RoCode kann keine Laufanimation erstellen: Erstell eine im Animation Editor und füg ihre ID ein. Mit Plugin 3.9.11 oder neuer kann RoCode dein Spiel in Studio playtesten und einen Test-Charakter steuern, um zu prüfen, ob es funktioniert, und mit Plugin 3.9.15 oder neuer kann der Test-Charakter Tasten drücken, zum Beispiel Shift halten und prüfen, ob die WalkSpeed gestiegen ist. Es entscheidet selbst, wann es einen Playtest macht, bis zu 2 pro Build plus 1, um die eigene Korrektur zu prüfen, und prüft nur, was es selbst zum Testen ausgewählt hat, also probier Sprint, Dash und Doppelsprung selbst aus und nutze den Device Simulator von Studio für die Handy-Buttons. Bewegung ist ein System unter vielen in einem Spiel; ein ganzes Spiel mit RoCode bauen läuft mit einem System pro Prompt wie diesem. Wie sich RoCode mit Studio verbindet.
Häufige Fragen
Warum funktioniert mein Sprint-Skript am Handy nicht?
Ein Handy hat keine Shift-Taste. Binde den Sprint mit ContextActionService:BindAction und übergib true als drittes Argument, das auf Touch-Geräten einen Button auf dem Bildschirm hinzufügt, wie es ShiftToSprint und MovementClient beide tun.
Sollte Sprinten auf dem Server laufen?
Nein. Jedes Gerät bewegt seinen eigenen Charakter, also hält eine WalkSpeed, die der Server setzt, keinen Cheater auf, der seine eigene setzen kann, und das neue Tempo kommt erst nach einem Hin- und Rückweg an, also startet der Sprint zu spät. Sprinte auf dem Client und prüf auf dem Server, wie weit sich Charaktere wirklich bewegen, wie in Schritt 5. Die Server-Authority-Beta von Roblox funktioniert anders und verlangt, dass der Bewegungscode umgeschrieben wird.
Warum sprintet mein Charakter weiter, nachdem ich Shift losgelassen habe?
Das Skript hat das Loslassen verpasst, meistens, weil es nur auf das Drücken hört. ContextActionService schickt End, wenn die Taste hochgeht, und Cancel, wenn eine andere Bindung sie übernimmt; MovementClient stoppt bei beidem, und auch, wenn die Stamina ausgeht oder der Charakter stehen bleibt.
Wie füge ich eine Sprint-Animation hinzu?
Lade im selben LocalScript eine Laufanimation über den Animator im Humanoid des Charakters, spiel sie ab, wenn der Sprint startet, und stopp sie, wenn er endet. Gib ihr die Priority Movement. Animationen, die an deinem eigenen Charakter starten, sehen alle.
Warum löst mein Doppelsprung am Handy von selbst aus?
Wenn du den Sprung-Button am Handy hältst, werden immer weiter Sprünge angefragt. Zähl einen Sprung erst als neu, wenn die Anfragen kurz aufhören, wie es das DoubleJump-Skript macht.
Was ist das Standard-Lauftempo in Roblox?
16 Studs pro Sekunde. Es kommt aus StarterPlayer.CharacterWalkSpeed, das die Humanoid.WalkSpeed jedes neuen Charakters setzt. Der Sprint aus diesem Guide addiert 10, also läuft Sprinten mit 26.
Wie schnell sollte Sprinten in Roblox sein?
Die meisten Spiele addieren zwischen der Hälfte und dem Ganzen des Lauftempos: Aus 16 wird irgendetwas zwischen 24 und 32. Ein kurzer, langsamer Sprint passt zu Horror und ein langer, schneller zu großen Maps. Die Vorlagen nach Spieltyp geben für jeden Typ Lauftempo, Sprint-Bonus und Stamina-Werte an.
Wie mache ich einen Sprint mit Stamina?
Halte eine Stamina-Zahl auf dem Gerät des Spielers, zieh in jedem Frame beim Sprinten etwas ab und füll sie nach einer kurzen Pause wieder auf, beides mit der Frame-Zeit skaliert, und stopp den Sprint, wenn sie 0 erreicht. MovementClient in Schritt 3 macht das mit einer Leiste auf dem Bildschirm; die Zahlen stehen in MovementConfig.
Wie sprinte ich mit einem Controller in Roblox?
Binde den ButtonL3 des Gamepads (den linken Stick eindrücken) mit ContextActionService zusammen mit Left Shift, wie es beide Skripte hier tun. ShiftToSprint macht L3 zu einem Umschalter, weil es anstrengend ist, den Stick eingedrückt zu halten, während du mit ihm lenkst.
Kommt sich Shift to Sprint mit Shift Lock in die Quere?
Kann passieren. Spieler, die Shift Lock in den Roblox-Einstellungen einschalten, schalten es mit der Shift-Taste um, also hat eine Taste zwei Aufgaben. Die Doku von Roblox sagt, dass die Shift-Lock-APIs gerade als veraltet eingestuft werden. Wenn der Konflikt deine Spieler stört, schalte StarterPlayer.EnableMouseLockOption aus, oder binde den Sprint in MovementClient an eine andere Taste wie Left Ctrl.
Quellen und weiterführende Links
- Roblox Creator Docs: ContextActionService (auf Englisch). BindAction, Touch-Buttons, die Grenze von 7 Buttons und warum es in den meisten Fällen besser ist als InputBegan
- Roblox Creator Docs: Humanoid (auf Englisch). WalkSpeed und sein Sicherheitshinweis, MoveDirection, StateChanged und ChangeState mit seinem Doppelsprung-Beispiel
- Roblox Creator Docs: LinearVelocity (auf Englisch). Plane-Modus, Tangentenachsen und MaxForce
- Roblox Creator Docs: Mover constraints (auf Englisch). das veraltete BodyVelocity in LinearVelocity umwandeln
- Roblox Creator Docs: UserInputService (auf Englisch). JumpRequest und warum es ein Debounce braucht
- Roblox Creator Docs: Network ownership, movement validation, and physics (auf Englisch). was ein Client steuert, Distanzprüfungen, Leaky Buckets und Ausnahmen für Teleports
- Roblox Creator Docs: Server authority model (auf Englisch). das Modell mit serverseitig simulierter Bewegung, BindToSimulation und die Workspace-Einstellungen, die es braucht
- Roblox Creator Docs: Input Action System (auf Englisch). das Character-Sprint-Beispiel mit InputAction und InputBinding
- Roblox Creator Docs: Custom abilities (auf Englisch). die Dash-Fähigkeit der Character Controller Library
- Roblox Creator Docs: Studio testing modes (auf Englisch). Device Simulator und Controller Emulator
So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 14. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.