Tutorial · Spielsysteme

Shift to Sprint in Roblox: Sprint-Skript für PC, Handy und Konsole

Mit Shift sprinten läuft in Roblox auf eine einzige Zahl hinaus: die WalkSpeed des Humanoids, die steigt, solange Shift gedrückt ist. Schritt 1 macht genau das in einem kurzen LocalScript, das auch mit dem Sprint-Button auf dem Handy und mit einem Gamepad funktioniert. Der Rest des Guides ergänzt, was ein größeres Spiel drumherum braucht: eine Stamina-Leiste (Ausdauer), einen Dash mit aktueller Physik, einen Doppelsprung, der einen gehaltenen Button ignoriert, und was der Server prüfen kann und was nicht.

Aktualisiert am 14. November 202626 Min. LesezeitGeschrieben von

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
  1. So funktioniert es
  2. 1. Mit Shift sprinten
  3. 2. Einstellungsmodul
  4. 3. Sprint und Dash
  5. 4. Doppelsprung
  6. 5. Server-Prüfung
  7. 6. Testen
  8. Tempo-Vorlagen
  9. Ältere Skripte
  10. Input Action System
  11. Erweitern
  12. Häufige Fehler
  13. Mit RoCode
  14. Häufige Fragen
  15. Quellen und weiterführende Links

So funktioniert Sprinten in Roblox

IllustrationShift sprintet mit WalkSpeed 26, während die Leiste schrumpft, Q macht einen Dash für ein Viertel der Leiste, und ein zweiter Sprungdruck in der Luft springt noch einmal.

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.

Die Teile des Bewegungssystems
TeilWo es liegtWas es macht
LocalScript ShiftToSprintStarterPlayerScriptsSchritt 1 für sich: Sprinten mit Tastatur, Handy und Gamepad, ohne Stamina. MovementClient ersetzt es, wenn du Stamina und einen Dash hinzufügst.
ModuleScript MovementConfigReplicatedStorageDie Zahlen: Sprint-Bonus, Stamina und Dash. Das LocalScript und die Server-Prüfung lesen es beide.
LocalScript MovementClientStarterPlayerScriptsBindet 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 DoubleJumpStarterCharacterScriptsGibt einen zusätzlichen Sprung in der Luft. In jedem neuen Charakter läuft eine frische Kopie.
Script MovementCheckServerScriptServiceMisst, wie weit sich jeder Charakter wirklich bewegt, und warnt im Output, wenn jemand dauerhaft schneller ist, als Sprint und Dash erlauben.
Der Explorer, wenn das Bewegungssystem fertig ist
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.

  1. Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts, klick auf + und füge ein LocalScript namens ShiftToSprint ein.
  2. Ersetz seinen Inhalt durch den Code unten und drück auf Play.
LocalScript in StarterPlayerScripts namens ShiftToSprint
-- 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?

Wie ShiftToSprint auf jedem Gerät sprintet, mit TOGGLE_ON_TOUCH_AND_GAMEPAD auf true
Gerät und EingabeFunktioniert alsWarum
Tastatur: Left ShiftHaltenEine Taste beim Laufen zu halten ist leicht, und Loslassen stoppt den Sprint sofort.
Gamepad: linken Stick klicken (L3)UmschaltenDen Stick eingedrückt zu halten, während du mit ihm lenkst, ist anstrengend.
Handy oder Tablet: der Sprint-Button auf dem BildschirmUmschaltenEin 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.

  1. Fahr im Explorer mit der Maus über ReplicatedStorage, klick auf + und füge ein ModuleScript ein.
  2. Benenn es in MovementConfig um und ersetz seinen Inhalt durch den Code unten.
ModuleScript in ReplicatedStorage namens MovementConfig
-- 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
Was jede Einstellung macht
EinstellungWertWirkung
SPRINT_BONUS10Wird beim Sprinten zur WalkSpeed addiert. Die Standard-WalkSpeed von Roblox ist 16, also läuft ein Sprint mit 26 Studs pro Sekunde.
MAX_STAMINA100Eine volle Leiste.
DRAIN_PER_SECOND20Eine volle Leiste reicht für 5 Sekunden Sprint.
REGEN_PER_SECOND15Eine leere Leiste braucht etwa 6,7 Sekunden, bis sie wieder voll ist.
REGEN_DELAY1Sekunden Pause, bevor das Auffüllen beginnt.
MIN_TO_START20Stamina, die zum Start eines Sprints nötig ist.
DASH_SPEED60Studs pro Sekunde während eines Dashs.
DASH_SECONDS0,2Wie lange ein Dash dauert: etwa 12 Studs bei 60 Studs pro Sekunde.
DASH_COST25Stamina, die jeder Dash kostet.
DASH_COOLDOWN1Sekunden 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.

  1. Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterPlayerScripts und füge ein LocalScript namens MovementClient ein.
  2. Ersetz seinen Inhalt durch den Code unten.
LocalScript in StarterPlayerScripts namens MovementClient
-- 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.

  1. Klapp im Explorer StarterPlayer auf, fahr mit der Maus über StarterCharacterScripts und füge ein LocalScript namens DoubleJump ein.
  2. Ersetz seinen Inhalt durch den Code unten.
LocalScript in StarterCharacterScripts namens DoubleJump
-- 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.

  1. Fahr mit der Maus über ServerScriptService und füge ein Script namens MovementCheck ein.
  2. Ersetz seinen Inhalt durch den Code unten.
Script in ServerScriptService namens MovementCheck
-- 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.

Was die Prüfung erwischt, aus ihren Zahlen berechnet
Ein Cheater, derWas MovementCheck macht
die WalkSpeed auf 100 setztWarnt nach etwa einer Sekunde Laufen
die WalkSpeed auf 50 setztWarnt 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 teleportiertWarnt bei der nächsten Prüfung
mit bis zu 38 Studs pro Sekunde läuft, etwa dem Anderthalbfachen des Sprint-TemposNichts: Unter 38,5 Studs pro Sekunde leert sich der Bucket so schnell, wie er sich füllt
seine eigene MovementConfig für endlose Stamina bearbeitetNichts: Ein Sprint mit 26 Studs pro Sekunde ist erlaubt, egal wie lange er dauert
fliegt, ohne Grenze springt oder durch Wände gehtNichts: 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:

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

  1. 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.
  2. 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.
  3. 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_SPEED oder DASH_SECONDS in MovementConfig.
  4. 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.
  5. Halte die Leertaste einen ganzen Sprung lang gedrückt. Du solltest einen Sprung bekommen, nicht zwei, weil der Luftsprung einen frischen Druck braucht.
  6. 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.
  7. Ö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.
  8. 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.
  9. 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.
  10. Wenn in deinem Place Workspace.PlayerScriptsUseInputActionSystem auf Enabled steht, teste den Doppelsprung noch einmal: Die Doku von Roblox sagt nicht, ob sich JumpRequest damit 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.

Lauftempo, Sprint und Stamina nach Spieltyp. Sprintdauer ist MAX_STAMINA / DRAIN_PER_SECOND; Auffüllen ist MAX_STAMINA / REGEN_PER_SECOND plus die 1 Sekunde REGEN_DELAY
SpieltypCharacterWalkSpeedSPRINT_BONUS (Sprint-Tempo)DRAIN_PER_SECONDREGEN_PER_SECONDVoller SprintLeer bis vollStrecke mit einer Leiste
Dieser Guide1610 (26)20155 s7,7 s130 Studs
Horror-Verfolgung128 (20)25104 s11 s80 Studs
Battlegrounds und Kampf1612 (28)15206,7 s6 setwa 187 Studs
Open World oder Simulator1616 (32)102510 s5 s320 Studs
Obby oder Parkour168 (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 addiert SPRINT_BONUS darauf, 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 in älteren Tutorials, und was dieser Guide stattdessen macht
MusterWarum es ein Problem istDieser Guide
BodyVelocity für einen DashVeraltet: Roblox sagt, stattdessen LinearVelocity zu nutzenLinearVelocity im Plane-Modus
Eine Schleife auf RunService.RenderSteppedFür neue Arbeit durch PreRender ersetzt. Spiellogik wie Stamina gehört auf Heartbeat, das Roblox für regelmäßige Aufgaben wie Health-Regeneration beschreibtHeartbeat 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 abAbzug und Auffüllen in jedem Frame mit deltaTime skaliert
UserInputService.InputBegan ohne Prüfung auf den ChatShift beim Tippen einer Chatnachricht startet einen SprintContextActionService, 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 setztExploiter setzen ihre eigene WalkSpeed trotzdem, und der Sprint startet einen Hin- und Rückweg zu spätSprint auf dem Client, plus eine Distanzprüfung auf dem Server
Ein Doppelsprung bei jedem JumpRequestJumpRequest feuert für eine Sprunganfrage mehrmals, und ein gehaltener Button kann immer weiter Sprünge anfragenEine Lücke von 0,25 Sekunden und eine Prüfung auf frischen Druck
UserInputService.TouchEnabled als "ist es Mobil?"-PrüfungEs ist true auf Laptops mit TouchscreenContextActionService fügt die Buttons auf Geräten mit Touch hinzu, ohne eigene Geräteprüfung
Humanoid:LoadAnimation für eine LaufanimationVeraltet zugunsten von Animator:LoadAnimationDie 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.

Du schreibst

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.

RoCode macht
  • 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

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.

Probier RoCode in deinem eigenen Spiel aus.

Jeden Tag kostenlose Credits, ohne Karte. Installiere das Plugin, beschreibe das Feature und prüfe, was in Studio ankommt.