Tutorial · Scripting-Grundlagen

RemoteEvents in Roblox: vom Client zum Server und zurück

Ein LocalScript kann nicht ändern, was andere Spieler sehen, und ein Server-Script kommt nicht an den Bildschirm eines einzelnen Spielers. RemoteEvents tragen Nachrichten zwischen beiden hin und her. Dieser Guide baut die drei Muster, die du am häufigsten brauchst, eine RemoteFunction, die eine Antwort zurückgibt, und die serverseitigen Prüfungen, die verhindern, dass ein manipulierter Client sie missbraucht.

Aktualisiert am 12. November 202618 Min. LesezeitGeschrieben von

Kurz gesagt

Ein RemoteEvent ist ein Objekt, das meist in ReplicatedStorage liegt und Nachrichten über die Grenze zwischen Client und Server schickt. Ein LocalScript ruft FireServer auf, und der Server hört es über OnServerEvent, wobei der sendende Player als erstes Argument dazukommt. Der Server ruft FireClient(player, ...) oder FireAllClients(...) auf, und LocalScripts hören es über OnClientEvent.

  • Nimm eine RemoteFunction (InvokeServer und OnServerInvoke) nur, wenn der Client eine Antwort zurückbraucht. Meide InvokeClient: Ein Client, der einen Fehler wirft, das Spiel verlässt oder nie antwortet, macht den Aufruf des Servers kaputt.
  • Vertrau nie dem, was ein Client schickt. Prüf auf dem Server den Typ, den Bereich und die Zugehörigkeit jedes Arguments, die Entfernung des Spielers und wie oft er feuert.
  • Funktionen, Metatables und Objekte, die die andere Seite nicht sehen kann, überstehen die Reise nicht. Ein UnreliableRemoteEvent kann Nachrichten verlieren oder umsortieren und verwirft jede Nutzlast über 1.000 Bytes.
Auf dieser Seite
  1. Warum es Remotes gibt
  2. Remotes einrichten
  3. 1. Client zum Server
  4. 2. Server zu einem Client
  5. 3. Server zu allen Clients
  6. RemoteFunctions
  7. Checkliste zur Prüfung
  8. Was sich nicht senden lässt
  9. Gibt nil zurück?
  10. UnreliableRemoteEvent
  11. Reihenfolge und Limits
  12. Was du nimmst
  13. Häufige Fehler
  14. Mit RoCode
  15. Häufige Fragen
  16. Quellen und weiterführende Links

Warum es RemoteEvents gibt

IllustrationJeder Klick bittet den Server, den Part zu färben, also zeigen die Bildschirme beider Spieler die neue Farbe.

Jedes Roblox-Spiel läuft als ein Server plus ein Client pro Spieler. Der Server ist die Autorität: Ein neues Objekt oder eine geänderte Eigenschaft erreicht nur dann jeden Spieler, wenn der Server die Änderung macht. Eine Änderung in einem LocalScript bleibt auf diesem einen Gerät, mit wenigen Ausnahmen wie dem eigenen Charakter des Spielers, dessen Bewegung sein Client steuert. Wenn also ein Klick oder ein Tastendruck die gemeinsame Welt ändern soll, muss der Client den Server fragen, und wenn der Server will, dass der Bildschirm eines Spielers reagiert, muss er es diesem Client sagen. Wenn die Trennung zwischen Script und LocalScript neu für dich ist, lies zuerst Script vs LocalScript vs ModuleScript (auf Englisch). Wenn Scripting selbst neu ist, fang mit Scripting in Roblox Studio für Anfänger an.

Roblox gibt dir drei Objekte, um diese Grenze zu überqueren:

  • RemoteEvent: eine Nachricht in eine Richtung. Der Sender macht sofort weiter.
  • RemoteFunction: eine Anfrage, die auf eine Antwort wartet. Der Aufrufer pausiert, bis die andere Seite einen Wert zurückgibt.
  • UnreliableRemoteEvent: eine Nachricht in eine Richtung, die verloren gehen oder in falscher Reihenfolge ankommen kann, dafür mit weniger Netzwerk-Overhead. Es passt zu Daten, die sich ständig ändern.
Welcher Aufruf welches Event feuert
RichtungSender ruft aufEmpfänger verbindet sich mitEmpfänger bekommt
Client zum Serverremote:FireServer(...) in einem LocalScriptremote.OnServerEvent in einem ScriptDen Player, der gefeuert hat, dann deine Argumente
Server zu einem Clientremote:FireClient(player, ...) in einem Scriptremote.OnClientEvent in einem LocalScriptNur deine Argumente
Server zu allen Clientsremote:FireAllClients(...) in einem Scriptremote.OnClientEvent in einem LocalScriptNur deine Argumente
Client fragt, Server antwortetremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Den Player, dann deine Argumente. Der Aufrufer bekommt zurück, was die Funktion zurückgibt

Clients können sich nicht direkt Nachrichten schicken. Um etwas von einem Spieler an die anderen weiterzugeben, feuerst du es an den Server, prüfst es dort und lässt den Server es mit FireClient oder FireAllClients weiterschicken. Die Sicherheitsempfehlung von Roblox lautet, dass der Server hier als Türsteher arbeitet und nie als bloße Weiterleitung.

Wohin deine Remotes gehören

Ein Remote muss dort liegen, wo sowohl der Server als auch die Clients es sehen können. Der übliche Ort ist ReplicatedStorage; die Doku von Roblox merkt an, dass in manchen Fällen auch Workspace oder ein Tool richtig sein kann. ServerStorage und ServerScriptService sind nur für den Server, also wartet ein LocalScript, das dort auf ein Remote wartet, für immer.

  1. Fahr im Explorer mit der Maus über ReplicatedStorage, klick auf den Button + und füge einen Folder ein. Nenn ihn Remotes.
  2. Fahr mit der Maus über Remotes, klick auf + und füge ein RemoteEvent ein. Benenn es so um, dass der Name seinen Zweck beschreibt, zum Beispiel PaintRequest.
  3. Wiederhol das für jedes Remote. Dieser Guide nutzt zwei RemoteEvents (PaintRequest und Notify) und eine RemoteFunction (RedeemCode).
Explorer: alles, was dieser Guide hinzufügt, Abschnitt für Abschnitt
ReplicatedStorage
  Remotes  Folder  new
    PaintRequest  RemoteEvent  new
    Notify  RemoteEvent  new
    RedeemCode  RemoteFunction  new
ServerScriptService
  PaintServer  Script  new
  WelcomeServer  Script  new
  FinishAnnouncer  Script  new
  RedeemServer  Script  new
  RemoteGuard  ModuleScript  new
StarterPlayer
  StarterPlayerScripts
    PaintClient  LocalScript  new
    NotifyClient  LocalScript  new
StarterGui
  CodeGui  ScreenGui  new
    CodeBox  TextBox  new
      RedeemClient  LocalScript  new
Workspace
  Paintable  Folder  new
  FinishLine  Part  new

Die Skripte in diesem Guide finden Remotes mit WaitForChild. Es kehrt sofort zurück, wenn das Remote schon da ist, und wartet, wenn nicht, zum Beispiel wenn ein Server-Script Remotes im laufenden Spiel erstellt. Nimm ein Remote pro Art von Anfrage: Jeder Server-Handler prüft dann eine einzige Form von Argumenten, was sich viel leichter richtig machen lässt als ein einziges Remote, das alles kann.

Muster 1: Client zum Server, vom Server geprüft

Die häufigste Aufgabe: Der Spieler macht etwas auf seinem Bildschirm, und der Server entscheidet, was passiert. Hier drückt der Spieler Q, um eine von vier Farben zu wählen, und klickt oder tippt auf einen Part, um ihn zu färben. Alle sehen die neue Farbe, weil der Server das Färben übernimmt.

Der Client schickt zwei Dinge: welchen Part und eine Farbnummer. Die Farbe selbst schickt er nie, und in anderen Spielen sollte er nie einen Preis, eine Belohnung oder einen Schadenswert schicken. Ein manipulierter Client kann alles schicken, also behält der Server die echten Daten (hier die Palette) und behandelt die Argumente als Anfrage, die er prüft.

  1. Füge in Workspace einen Folder namens Paintable ein und leg ein paar verankerte Parts hinein.
  2. Prüf, dass ReplicatedStorage.Remotes ein RemoteEvent namens PaintRequest enthält.
  3. Füge in ServerScriptService ein Script namens PaintServer ein und unter StarterPlayer, StarterPlayerScripts ein LocalScript namens PaintClient, mit dem Code unten.
Script in ServerScriptService namens PaintServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local remotes = ReplicatedStorage:WaitForChild("Remotes")
local paintRequest = remotes:WaitForChild("PaintRequest") :: RemoteEvent
local paintable = workspace:WaitForChild("Paintable")

-- Der Server besitzt die Farben. Der Client schickt nur eine Zahl, die eine auswählt.
local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local MAX_DISTANCE = 30 -- Studs zwischen dem Charakter und dem Part
local COOLDOWN_SECONDS = 0.25

local lastPaint: { [Player]: number } = {}

-- Der erste Parameter ist immer der Spieler, der gefeuert hat. Roblox trägt ihn ein,
-- also kann man ihm vertrauen. Alles danach kam vom Client, dem kann man nicht vertrauen.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Typ: ein echter Part, keine Tabelle, die nur so tut
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Bereich: eine ganze Zahl von 1 bis 4. NaN und unendlich scheitern hier auch.
	if type(colourIndex) ~= "number" or not math.isfinite(colourIndex) then
		return
	end
	if colourIndex % 1 ~= 0 or colourIndex < 1 or colourIndex > #PALETTE then
		return
	end

	-- 3. Erlaubtes Ziel: nur Parts im Ordner Paintable, sonst nichts im Spiel
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Entfernung: der Charakter des Spielers muss nahe am Part sein
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	if not (root and root:IsA("BasePart")) then
		return
	end
	if (root.Position - part.Position).Magnitude > MAX_DISTANCE then
		return
	end

	-- 5. Rate-Limit: einmal färben pro Spieler pro Viertelsekunde
	local now = os.clock()
	local last = lastPaint[player]
	if last and now - last < COOLDOWN_SECONDS then
		return
	end
	lastPaint[player] = now

	part.Color = PALETTE[colourIndex]
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastPaint[player] = nil
end)

Jede fehlgeschlagene Prüfung kehrt einfach zurück. Einem schummelnden Client musst du nicht sagen, warum er abgelehnt wurde.

LocalScript in StarterPlayerScripts namens PaintClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")

local remotes = ReplicatedStorage:WaitForChild("Remotes")
local paintRequest = remotes:WaitForChild("PaintRequest") :: RemoteEvent
local paintable = workspace:WaitForChild("Paintable")

local COLOUR_COUNT = 4 -- der Server hält die echten Farben
local selectedColour = 1

-- Der Strahl darf nur Parts im Ordner Paintable treffen
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- die Taste oder der Klick ging an den Chat oder einen Button
	end

	if input.KeyCode == Enum.KeyCode.Q then
		selectedColour = selectedColour % COLOUR_COUNT + 1
		return
	end

	local isClick = input.UserInputType == Enum.UserInputType.MouseButton1
	local isTap = input.UserInputType == Enum.UserInputType.Touch
	if isClick or isTap then
		local camera = workspace.CurrentCamera
		local ray = camera:ScreenPointToRay(input.Position.X, input.Position.Y)
		local result = workspace:Raycast(ray.Origin, ray.Direction * 500, rayParams)
		if result then
			-- Fragen, nicht befehlen: der Server entscheidet, ob gefärbt wird
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed ist true, wenn die Engine die Eingabe schon verarbeitet hat, meist in der UI: ein Klick auf einen Button oder Tasten, die in ein Textfeld wie die Chatleiste getippt werden. Die Prüfung sorgt dafür, dass ein Q in einer Nachricht nicht die Farbe wechselt.

Muster 2: Server zu einem Client

Der Server schickt mit FireClient eine Nachricht an einen Spieler. Das erste Argument ist der Player, an den sie geht, und der Handler des Clients bekommt nur die Argumente danach. Nimm das für alles Persönliche: eine Benachrichtigung, ein Belohnungs-Popup, einen Sound, den nur dieser Spieler hören soll. Der Guide zu Cutscenes ist ein größeres ausgearbeitetes Beispiel: Der Server entscheidet, wann ein Spieler eine Cutscene sieht, und schickt ihre Einstellungen mit FireClient an diesen einen Spieler, und dessen Gerät bewegt die Kamera.

Dieses Paar zeigt eine Willkommensnachricht, wenn ein Spieler beitritt. Das LocalScript baut sein eigenes kleines Banner, also musst du kein GUI einrichten.

Script in ServerScriptService namens WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent

local function welcome(player: Player)
	-- Das erste Argument bestimmt, welcher Client es bekommt. Sonst sieht das niemand.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- In Studio kannst du beitreten, bevor dieses Skript verbunden ist, also begrüß alle, die schon da sind
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript in StarterPlayerScripts namens NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local player = Players.LocalPlayer

-- Ein kleines Banner oben am Bildschirm, im Code gebaut
local gui = Instance.new("ScreenGui")
gui.Name = "Notifications"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

local label = Instance.new("TextLabel")
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 16)
label.Size = UDim2.fromOffset(420, 44)
label.BackgroundColor3 = Color3.fromRGB(18, 11, 31)
label.TextColor3 = Color3.new(1, 1, 1)
label.TextScaled = true
label.Visible = false
label.Parent = gui

local messageCount = 0

-- Hier kein player-Parameter: der Server hat schon gewählt, wer es bekommt
notify.OnClientEvent:Connect(function(message: string)
	messageCount += 1
	local thisMessage = messageCount
	label.Text = message
	label.Visible = true
	task.delay(4, function()
		if messageCount == thisMessage then -- ausblenden, außer eine neuere Nachricht hat es ersetzt
			label.Visible = false
		end
	end)
end)

Der Server feuert bei PlayerAdded, was passieren kann, bevor dieses LocalScript seinen Handler verbunden hat. Das ist in Ordnung: Roblox reiht RemoteEvent-Nachrichten ein, die ankommen, bevor ein Handler existiert, und liefert sie der Reihe nach aus, sobald sich einer verbindet.

Der Client muss sich nicht gegen den Server absichern: Nur Server-Code kann OnClientEvent feuern. Die Annotation message: string ist für den Typ-Checker; sie ist keine Prüfung zur Laufzeit.

Muster 3: Server zu allen Clients

FireAllClients schickt dieselbe Nachricht an jeden verbundenen Spieler. Es nimmt kein Player-Argument, und jeder Client empfängt sie über dasselbe OnClientEvent wie zuvor, also zeigt das Skript NotifyClient aus Muster 2 sie bereits an.

Dieses Script verkündet allen, wenn ein Spieler zum ersten Mal eine Ziellinie berührt. Füge einen verankerten Part namens FinishLine in Workspace ein und dann das Script in ServerScriptService.

Script in ServerScriptService namens FinishAnnouncer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local finishLine = workspace:WaitForChild("FinishLine") :: BasePart

local finished: { [Player]: boolean } = {}

finishLine.Touched:Connect(function(hit: BasePart)
	local character = hit:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player or finished[player] then
		return -- kein Spieler, oder schon angekündigt
	end
	finished[player] = true

	-- Jeder verbundene Client führt seinen OnClientEvent-Handler mit diesem Text aus
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

Players.PlayerRemoving:Connect(function(player: Player)
	finished[player] = nil
end)

Ein Exploiter kann Touched für seinen eigenen Charakter aus jeder Entfernung auslösen, was bei einer Ankündigung, die pro Spieler einmal erscheint, harmlos ist. Wenn du später eine Belohnung fürs Ankommen gibst, füge vor dem Auszahlen Server-Prüfungen hinzu, etwa eine Mindestzeit seit Rundenstart.

FireAllClients erreicht nur die Spieler, die in diesem Moment verbunden sind. Wer eine Sekunde später beitritt, sieht die Nachricht nie. Das passt für einmalige Momente wie eine Ankündigung, einen Explosionseffekt oder einen Sound, aber nicht für Zustand wie einen Rundentimer oder die aktuelle Spielphase. Für Zustand setzt du ein Attribut auf dem Server, zum Beispiel ReplicatedStorage:SetAttribute("TimeLeft", 30), und liest es auf dem Client mit GetAttribute und GetAttributeChangedSignal("TimeLeft"). Attribute werden an jeden Client repliziert, auch an Spieler, die später beitreten.

RemoteFunction: wenn der Client eine Antwort braucht

Ein RemoteEvent wird gefeuert und vergessen. Eine RemoteFunction lässt den Aufrufer warten: InvokeServer pausiert den aufrufenden Code, bis die Funktion OnServerInvoke des Servers zurückkehrt, und gibt dann zurück, was sie zurückgegeben hat. Nimm eine, wenn der Client ohne die Antwort nicht weitermachen kann, etwa bei der Frage, ob ein Code gültig war. Wenn du keine Antwort brauchst, empfiehlt Roblox ein RemoteEvent, weil es nicht wartet.

Beispiel: ein Feld, in das Spieler einen Belohnungscode tippen. Der Server hält die Codes, prüft den Text und gibt zwei Werte zurück: ob es geklappt hat und eine Nachricht zum Anzeigen.

  1. Füge in ReplicatedStorage.Remotes eine RemoteFunction namens RedeemCode ein.
  2. Füge in StarterGui ein ScreenGui namens CodeGui ein und darin eine TextBox namens CodeBox. Größe und Position wählst du, wie du magst.
  3. Füge das Script unten in ServerScriptService ein und das LocalScript in CodeBox.
Script in ServerScriptService namens RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction

-- Codes liegen auf dem Server, wo kein Spieler sie lesen kann
local CODES: { [string]: number } = {
	LAUNCH = 100,
	THANKYOU = 50,
}
local MAX_LENGTH = 20
local COOLDOWN_SECONDS = 2

local usedCodes: { [Player]: { [string]: boolean } } = {}
local lastTry: { [Player]: number } = {}

-- Mit = zuweisen. OnServerInvoke ist ein Callback, kein Event, mit dem du dich per Connect verbindest.
redeemCode.OnServerInvoke = function(player: Player, code: unknown): (boolean, string)
	local now = os.clock()
	local last = lastTry[player]
	if last and now - last < COOLDOWN_SECONDS then
		return false, "Wait a moment before trying again"
	end
	lastTry[player] = now

	if type(code) ~= "string" or #code == 0 or #code > MAX_LENGTH then
		return false, "Type a code first"
	end

	local key = string.upper(code)
	local reward = CODES[key]
	if not reward then
		return false, "That code doesn't exist"
	end

	local used = usedCodes[player]
	if not used then
		used = {}
		usedCodes[player] = used
	end
	if used[key] then
		return false, "You already used that code"
	end

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if not (coins and coins:IsA("IntValue")) then
		return false, "Coins aren't set up in this game yet"
	end

	used[key] = true
	coins.Value += reward
	return true, `Code accepted: +{reward} coins`
end

Players.PlayerRemoving:Connect(function(player: Player)
	usedCodes[player] = nil
	lastTry[player] = nil
end)

Es erhöht den Stat Coins aus dem Leaderboard-Guide. Benutzte Codes werden nur gemerkt, bis der Spieler geht, also kann ein Spieler in dieser Fassung neu beitreten und denselben Code noch einmal einlösen. Wenn Coins gespeichert werden, sind das Gratis-Coins bei jedem Wiederbeitritt: Bevor ein Live-Spiel das nutzt, speichere die benutzten Codes jedes Spielers mit seinen gespeicherten Daten in einem Data Store.

LocalScript in der TextBox CodeBox namens RedeemClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
local box = script.Parent :: TextBox

local GREEN = Color3.fromRGB(46, 204, 113)
local RED = Color3.fromRGB(231, 76, 60)

box.FocusLost:Connect(function(enterPressed: boolean)
	local code = box.Text
	if not enterPressed or code == "" then
		return
	end
	box.Text = ""
	box.PlaceholderText = "Checking..."

	-- InvokeServer pausiert diese Funktion, bis der Callback des Servers zurückkehrt.
	-- pcall hält das LocalScript am Laufen, wenn der Aufruf fehlschlägt.
	local ok, accepted, message = pcall(function()
		return redeemCode:InvokeServer(code)
	end)

	if ok and type(message) == "string" then
		box.PlaceholderText = message
		box.PlaceholderColor3 = if accepted == true then GREEN else RED
	else
		box.PlaceholderText = "Something went wrong, try again"
		box.PlaceholderColor3 = RED
	end
end)

Eine RemoteFunction hat genau einen Server-Callback. Wenn zwei Skripte OnServerInvoke an derselben RemoteFunction setzen, läuft nur das letzte.

Warum InvokeClient riskant ist

Eine RemoteFunction funktioniert auch andersherum, mit InvokeClient auf dem Server und OnClientInvoke auf dem Client. Die Dokumentation von Roblox nennt drei ernste Risiken:

  • Wenn der Callback des Clients einen Fehler wirft, wirft auch der Server den Fehler.
  • Wenn der Spieler während des Aufrufs geht, wirft InvokeClient einen Fehler.
  • Wenn der Client nie einen Wert zurückgibt, wartet das Server-Script für immer.

Ein manipulierter Client kontrolliert seinen eigenen Callback, also kann ein Cheater den dritten Fall absichtlich auslösen und diesen Server-Thread so lange festhalten, wie er will. Um den Bildschirm eines Spielers zu aktualisieren, nimm FireClient. Wenn der Server wirklich Informationen von einem Client braucht, feuere ein RemoteEvent, lass den Client über ein anderes RemoteEvent antworten und behandle eine fehlende Antwort auf dem Server als normalen Fall.

Jedes Argument auf dem Server prüfen

Ein Exploiter kann jedes RemoteEvent feuern und jede RemoteFunction aufrufen, so oft er will, mit beliebigen Argumenten. Das Einzige, was er nicht fälschen kann, ist der erste Parameter: Roblox trägt den Player ein, der gesendet hat. Alles danach muss geprüft werden, bevor der Server darauf reagiert. Das Remote zu verstecken oder im LocalScript zu prüfen hilft nicht, weil der Cheater seinen eigenen Client kontrolliert.

Die Checkliste für den Server
PrüfungDie Frage, die der Server stelltBeispiel
TypIst es der Typ, den ich erwarte? Eine Instance, keine Tabelle, die nur so aussehen soll?typeof(part) == "Instance" and part:IsA("BasePart")
BereichIst die Zahl endlich und im erlaubten Bereich? Hat der Text eine vernünftige Länge?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
ZugehörigkeitBesitzt dieser Spieler das Item, hat er das Geld oder das Recht, mit diesem Objekt etwas zu tun?Das Item ist in seinem Inventar; der Part liegt in Paintable
EntfernungIst der Charakter des Spielers in der Kopie der Welt auf dem Server nah genug? Lass etwas Spielraum für Lag.Höchstens 30 Studs vom Part entfernt
RateSendet dieser Spieler zu schnell?Ein Cooldown pro Spieler oder ein Kontingent, das sich wieder auffüllt

NaN verdient eine eigene Warnung. Es ist eine Zahl, also besteht es type(x) == "number", aber jeder Vergleich damit ist false, also lässt eine Prüfung wie x < 0 or x > 100 es einfach durch. math.isfinite(x) lehnt NaN und beide Unendlichkeiten ab.

Kenn die Grenze einer Entfernungsprüfung. Jeder Client steuert die Physik seines eigenen Charakters, also kann ein Exploiter seinen Charakter vor dem Feuern neben das Ziel bewegen. Die Prüfung stoppt trotzdem den einfachen Missbrauch, von einer Stelle aus auf der ganzen Map zu handeln. Halt Ziel-Parts außerdem verankert: Die Security-Doku von Roblox merkt an, dass ein Exploiter die Network Ownership nicht verankerter Parts in seiner Nähe übernehmen und diese Parts heranziehen kann, was eine Entfernungsprüfung umgeht.

Hier sind dieselben Prüfungen als ModuleScript, das du in jedem Remote-Handler wiederverwenden kannst.

ModuleScript in ServerScriptService namens RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Eine echte Zahl zwischen min und max. Lehnt NaN und unendlich ab, die eine
-- einfache Prüfung type(x) == "number" bestehen.
function RemoteGuard.number(value: unknown, min: number, max: number): number?
	if type(value) ~= "number" or not math.isfinite(value) then
		return nil
	end
	if value < min or value > max then
		return nil
	end
	return value
end

-- Eine ganze Zahl zwischen min und max, für Anzahlen, Indizes und Mengen
function RemoteGuard.integer(value: unknown, min: number, max: number): number?
	local n = RemoteGuard.number(value, min, max)
	if n and n % 1 == 0 then
		return n
	end
	return nil
end

-- Text mit einer Längengrenze. utf8.len gibt für ungültiges UTF-8 nil zurück, das
-- Data Stores ablehnen.
function RemoteGuard.text(value: unknown, maxLength: number): string?
	if type(value) ~= "string" or #value > maxLength or utf8.len(value) == nil then
		return nil
	end
	return value
end

-- Eine Instance der erwarteten Klasse, innerhalb des Containers, den du erlaubst.
-- Eine Tabelle, die wie eine Instance aussehen soll, scheitert an der typeof-Prüfung.
function RemoteGuard.instanceIn(value: unknown, className: string, container: Instance): Instance?
	if typeof(value) ~= "Instance" then
		return nil
	end
	if not value:IsA(className) or not value:IsDescendantOf(container) then
		return nil
	end
	return value
end

-- True, wenn der Charakter des Spielers höchstens maxDistance Studs von position entfernt ist
function RemoteGuard.isNear(player: Player, position: Vector3, maxDistance: number): boolean
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	if not (root and root:IsA("BasePart")) then
		return false
	end
	return (root.Position - position).Magnitude <= maxDistance
end

-- Ein Rate-Limit pro Spieler. Jeder Spieler darf `burst` Aufrufe auf einmal machen und
-- bekommt jede Sekunde `perSecond` Aufrufe zurück. Gibt eine Funktion zurück, die du vor
-- der Arbeit aufrufst: sie antwortet true (nur zu) oder false (zu schnell).
function RemoteGuard.limiter(burst: number, perSecond: number): (Player) -> boolean
	local buckets: { [Player]: { tokens: number, updated: number } } = {}

	Players.PlayerRemoving:Connect(function(player: Player)
		buckets[player] = nil
	end)

	return function(player: Player): boolean
		local now = os.clock()
		local bucket = buckets[player]
		if not bucket then
			bucket = { tokens = burst, updated = now }
			buckets[player] = bucket
		end
		bucket.tokens = math.min(burst, bucket.tokens + (now - bucket.updated) * perSecond)
		bucket.updated = now
		if bucket.tokens < 1 then
			return false
		end
		bucket.tokens -= 1
		return true
	end
end

return RemoteGuard

Lass es in ServerScriptService. Code dort erreicht nie die Clients, also kann niemand deine Prüfungen lesen.

Und hier ist der Handler aus Muster 1, damit neu geschrieben. Ersetz den Inhalt von PaintServer:

Script in ServerScriptService namens PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" zählt nur für den strikten Typ-Checker von Luau; zur Laufzeit ändert es nichts
local RemoteGuard = require(ServerScriptService:WaitForChild("RemoteGuard")) :: any

local paintRequest = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("PaintRequest") :: RemoteEvent
local paintable = workspace:WaitForChild("Paintable")

local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local canPaint = RemoteGuard.limiter(4, 4) -- ein Burst von 4, dann 4 pro Sekunde

paintRequest.OnServerEvent:Connect(function(player: Player, partArg: unknown, colourArg: unknown)
	local part = RemoteGuard.instanceIn(partArg, "BasePart", paintable) :: BasePart?
	local colourIndex = RemoteGuard.integer(colourArg, 1, #PALETTE) :: number?
	if not part or not colourIndex then
		return
	end
	if not RemoteGuard.isNear(player, part.Position, 30) or not canPaint(player) then
		return
	end
	part.Color = PALETTE[colourIndex]
end)

Der Limiter entfernt den Eintrag jedes Spielers, wenn er geht, also wächst seine Tabelle nicht über die ganze Lebensdauer des Servers.

Bei Waffen zählen diese Prüfungen am meisten: Lass nie den Client sagen, wer getroffen wurde. Das Remote im Schwert-Guide trägt überhaupt keine Argumente, und der Server findet die Ziele selbst. Der Guide zu Schusswaffen (auf Englisch) schickt nur einen Zielpunkt, den der Server auf Typ, NaN und Entfernung prüft, bevor er seinen eigenen Strahl schießt.

Für Menüs gilt dieselbe Regel: Schick eine Auswahl, nie das Ergebnis. Im Guide zu NPC-Dialogen schickt der Client nur die Nummer des gedrückten Buttons, und der Server schlägt nach, was diese Antwort gibt. Das Menü im Teleporter-Guide schickt einen Spot-Namen, keine Position, und der Server findet den Spot in seinem eigenen Ordner und prüft die Wins, die er braucht.

Was du senden kannst und was nicht

Du kannst Zahlen, Strings, Booleans, Roblox-Typen wie Vector3, CFrame, Color3 und Enum-Items, Instances, die beide Seiten sehen können, und Tabellen daraus übergeben. Manche Werte ändern sich unterwegs oder verschwinden:

Argumente, die nicht so ankommen, wie sie gesendet wurden
Du sendestWas passiert
Eine FunktionDie andere Seite bekommt nil
Eine Tabelle mit MetatableDie Metatable geht verloren, zusammen mit allem, was die Tabelle nur durch sie hatte
Eine Tabelle, die Zahlen-Keys und String-Keys mischtRoblox rät davon ab: Sende ein reines Array oder ein reines Dictionary
Eine Tabelle mit nil-Werten darinVermeiden: Roblox rät von nil an jedem Index ab
Eine Tabelle mit Instance-, userdata- oder Funktions-KeysDiese Keys werden in Strings umgewandelt
Eine Instance, die der Empfänger nicht sehen kann, etwa eine in ServerStorage oder eine, die ein LocalScript erstellt hatDie andere Seite bekommt nil
Irgendeine TabelleDer Empfänger bekommt eine Kopie, nie dieselbe Tabelle

Eine gute Gewohnheit ist, Bezeichner statt Objekten oder Werten zu senden: den Namen eines Items, den Index einer Auswahl, einen Part, den der Server nachschlagen und prüfen kann. Der Server arbeitet dann mit seinen eigenen Daten.

Warum eine RemoteFunction nil zurückgibt

Wenn InvokeServer dir nil gibt, geh diese Punkte der Reihe nach durch:

  1. Ein Pfad ohne Rückgabewert. Jeder Weg aus OnServerInvoke heraus muss etwas zurückgeben. Ein nacktes return in einer frühen Prüfung schickt nil zurück.
  2. Ein return in einer verschachtelten Funktion. Ein return in pcall(function() ... end), einem :Connect-Handler oder task.spawn verlässt nur diese innere Funktion. Fang das Ergebnis auf, zum Beispiel mit local ok, data = pcall(...), und gib dann data aus dem Callback selbst zurück.
  3. Ein Wert, der die Grenze nicht überqueren kann. Eine Funktion oder eine Instance, die der Client nicht sehen kann (zum Beispiel alles in ServerStorage), kommt als nil an. Mit Instance Streaming hat ein Part, den der Server gerade erst erstellt hat, den Client vielleicht noch nicht erreicht, wenn die Funktion zurückkehrt.
  4. Ein anderes Skript hat den Callback gesetzt. Nur die letzte Zuweisung an OnServerInvoke läuft. Durchsuch deine Skripte nach dem Namen des Remotes.

Wenn der Aufruf überhaupt nie zurückkehrt, hat noch kein Skript OnServerInvoke gesetzt (Roblox reiht die Aufrufe ein, bis eins es tut), oder der Callback hängt fest, zum Beispiel an einem WaitForChild für etwas, das nie auftaucht.

UnreliableRemoteEvent: für ständige Wegwerf-Updates

Ein UnreliableRemoteEvent hat dieselben Methoden und Events wie ein RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent und OnClientEvent. Der Unterschied ist, dass Roblox weder die Zustellung noch die Reihenfolge garantiert. Eine Nachricht kann verworfen werden, ohne erneut gesendet zu werden, wenn:

  • sie unterwegs verloren geht oder in einem überlasteten Netzwerk zu lange wartet
  • ihre Nutzlast größer als 1.000 Bytes ist
  • ein Client schneller feuert als das Rate-Limit (der Überschuss wird verworfen, nicht verzögert)
  • kein Handler verbunden ist, wenn sie ankommt (sie wird verworfen, nicht eingereiht)

Nachrichten können auch in falscher Reihenfolge ankommen, und sie stehen in keiner festen Reihenfolge zu deinen RemoteEvents oder RemoteFunctions. Nimm eins, wenn nur der neueste Wert zählt und das nächste Update einen Sekundenbruchteil entfernt ist: wohin ein Spieler zielt, die Position eines kosmetischen Effekts, ein Wert, der sich jeden Frame ändert. Wenn die Reihenfolge zählt, pack eine Sequenznummer oder einen Zeitstempel in jede Nachricht und ignoriere alles, was älter ist als die letzte, die du verarbeitet hast.

Nimm nie eins für etwas, das genau einmal passieren muss, etwa einen Kauf, Schaden, eine Belohnung oder einen Rundenstart. Und prüf seine Argumente auf dem Server genau so, wie du es bei einem RemoteEvent tun würdest.

Zustellreihenfolge und Rate-Limits

Die Zustellgarantien von Roblox gelten für eine Verbindung in eine Richtung: der Server zu einem Client oder ein Client zum Server.

  • RemoteEvents sind zuverlässig und geordnet. Verlorene Nachrichten werden erneut gesendet, solange der Empfänger verbunden bleibt, und Nachrichten kommen in der Reihenfolge an, in der du sie gefeuert hast, auch über verschiedene RemoteEvents hinweg. Wenn der Server A, dann B, dann A an einen Spieler feuert, empfängt dieser Spieler A, B, A.
  • Die Reihenfolge betrifft den Start der Handler. Wenn ein Handler pausiert, zum Beispiel mit task.wait oder WaitForChild, kann die Verarbeitung der nächsten Nachricht beginnen, bevor die erste fertig ist.
  • RemoteFunctions und RemoteEvents sind untereinander nicht geordnet. Wenn dein Code von einer strikten Reihenfolge abhängt, schick zusammengehörige Nachrichten über denselben Remote-Typ oder füge eine eigene Sequenznummer hinzu.
  • Änderungen an Eigenschaften und Attributen sind gegenüber Remotes nicht geordnet. Wenn der Server eine Eigenschaft ändert und dann ein Remote feuert, kann der Client das eine oder das andere zuerst sehen. Hör auf die Änderung selbst, zum Beispiel mit GetPropertyChangedSignal, statt anzunehmen, dass sie schon angekommen ist.
  • Noch kein Handler. RemoteEvent-Nachrichten werden eingereiht, bis sich ein Handler verbindet. Die Warteschlange hat Grenzen: Ist sie voll, werden weitere Nachrichten verworfen, und Output zeigt den Fehler Remote event invocation discarded.
  • Ein Spieler, der geht, verliert alle Nachrichten, die ihn noch nicht erreicht hatten.

Rate-Limit. Nachrichten von RemoteEvents und UnreliableRemoteEvents von einem Client an den Server werden bei etwa 500 Anfragen pro Sekunde pro Client gedrosselt, so dokumentiert am 30. September 2026. Das Limit teilen sich alle Remotes desselben Typs, also erhöht es nichts, ein viel genutztes Remote auf zehn aufzuteilen. Über dem Limit werden RemoteEvent-Nachrichten später verarbeitet und behalten ihre Reihenfolge, während UnreliableRemoteEvent-Nachrichten verworfen werden. Das Limit der Engine hindert einen einzelnen Spieler nicht daran, dein Remote 50 Mal pro Sekunde zu feuern, also braucht jeder Handler, der etwas ändert, trotzdem sein eigenes Limit pro Spieler.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent oder Attribut?

Wie Client und Server miteinander reden sollen
NimmFürBeispielAchte auf
RemoteEventNachrichten in eine Richtung, die ankommen müssen, in ReihenfolgeClient: „Färb diesen Part“. Server: „Zeig diesen Hinweis“Jedes Argument auf dem Server prüfen
RemoteFunction mit InvokeServerDer Client braucht eine Antwort, bevor er weitermachen kannEinen Code einlösen, einen Kauf bestätigenDer Aufrufer wartet; jeder Pfad muss einen Wert zurückgeben
RemoteFunction mit InvokeClientFast nieNimm stattdessen FireClientEin Client, der einen Fehler wirft, geht oder nie antwortet, macht den Server-Aufruf kaputt oder friert ihn ein
UnreliableRemoteEventHäufige Updates, bei denen nur das neueste zähltZielrichtung, kosmetische EffekteNachrichten gehen verloren oder werden umsortiert; Nutzlast höchstens 1.000 Bytes
Attribut oder Value-Objekt, das der Server setztGemeinsamer Zustand, der immer sichtbar sein soll, auch für Spieler, die später beitretenRundentimer, Spielphase, ob eine Tür offen istNur Änderungen des Servers erreichen alle; Clients hören mit GetAttributeChangedSignal oder Changed
BindableEventSkripte auf derselben Seite, die miteinander redenEin Server-Script sagt einem anderen, dass eine Runde vorbei istÜberquert nicht die Grenze zwischen Server und Client

Ein vollständiges Beispiel, in dem RemoteFunctions und Prüfungen bei etwas zusammenarbeiten, wofür Spieler bezahlen, findest du im Guide zum Shop-GUI. Zur Zeile mit dem Attribut: Das Server-Script im Tür-Guide setzt bei jeder Bewegung ein Attribut Open an jeder Tür, sodass jedes LocalScript darauf reagieren kann.

Häufige Fehler und Lösungen

Die meisten Probleme mit Remotes zeigen sich im Output-Fenster (öffne es über das Menü Window oder den Tab Script). Schau dort zuerst nach und such dann unten das passende Symptom. Der Guide zu Skriptfehlern erklärt die allgemeinen Fehlermeldungen ausführlicher.

Infinite yield possible bei einem WaitForChild für ein Remote

Ein Skript wartet auf ein Remote, das nie ankommt. Prüf, dass Name und Groß- und Kleinschreibung exakt stimmen und dass das Remote in ReplicatedStorage liegt, nicht in ServerStorage oder ServerScriptService, die Clients nicht sehen können.

Der Server bekommt die falschen Werte, um eins verschoben

Das LocalScript hat den Spieler selbst übergeben, wie in remote:FireServer(player, 5). Roblox fügt den Sender bereits als ersten Parameter hinzu, also sieht der Server (player, player, 5). Ruf remote:FireServer(5) auf.

Nichts passiert, wenn ich das Remote feuere

Prüf, dass jeder Aufruf auf der richtigen Seite läuft: FireServer und InvokeServer funktionieren nur aus Client-Code, und FireClient, FireAllClients und InvokeClient nur aus einem Server-Script. Ein LocalScript läuft nie in ServerScriptService, ServerStorage oder direkt in Workspace; leg es in StarterPlayerScripts, StarterGui, StarterCharacterScripts oder StarterPack. Schau dann in Output nach einem Fehler im Handler.

Remote event invocation discarded

Für ein RemoteEvent ohne verbundenen Handler kamen Nachrichten an, und die Warteschlange lief voll. Meist wirft das Handler-Skript vor seiner :Connect-Zeile einen Fehler, ist deaktiviert oder wartet auf etwas, das nie lädt. Verbinde Handler weit oben im Skript.

Bei mir funktioniert es, aber andere Spieler sehen die Änderung nicht

Die Änderung wurde auf dem Client gemacht, in einem LocalScript oder einem OnClientEvent-Handler. Mach sie stattdessen im OnServerEvent-Handler des Servers.

InvokeServer kehrt nie zurück

Entweder hat kein Skript OnServerInvoke gesetzt (Roblox reiht Aufrufe ein, bis eins es tut), oder der Callback hängt an etwas, das pausiert, etwa einem WaitForChild oder einer Data-Store-Anfrage. Setz ein print an den Anfang und das Ende des Callbacks, um zu sehen, wo er stehen bleibt.

Mit RoCode bauen

Du kannst das auch von RoCode in dem Spiel einrichten lassen, das du offen hast. RoCode ist ein KI-Agent, der über ein Roblox-Studio-Plugin arbeitet, also erstellt er die Remotes und Skripte in deinem Explorer, statt dir Code zum Einfügen zu geben. Prompts kannst du auf Deutsch schreiben.

Du schreibst

Lass Spieler Parts im Ordner Paintable anklicken, um sie zu färben. Nutz ein RemoteEvent und lass die Prüfungen auf dem Server: nur Parts in diesem Ordner, höchstens 30 Studs entfernt und nicht mehr als ein paar Mal färben pro Sekunde.

RoCode macht
  • Durchsucht meist zuerst das Spiel, mit Search Game und Search Scripts, nach einem vorhandenen Remotes-Ordner oder Handler und nutzt deine vorhandenen Ordner, wenn es sie gibt
  • Erstellt das RemoteEvent in ReplicatedStorage mit Create Instance und schreibt das Server-Script und das LocalScript mit Create Script
  • Prüft jedes Skript vor dem Abschluss in Studio mit Check Script auf Kompilierfehler. Das findet Kompilierfehler, keine Logikfehler: Es macht keine Typprüfung, kein Linting und führt deinen Code nicht aus
  • Schickt seine Änderungen in Runden, und jede Runde ist ein Undo-Punkt im Verlauf von Studio

Mit Plugin 3.9 oder neuer kann RoCode einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.11 oder neuer kann es einen Test-Charakter steuern, aber es klickt keine Parts in der 3D-Ansicht an. Drück selbst auf Play und versuch, die Prüfungen zu knacken, zum Beispiel indem du vom anderen Ende der Map färbst. Wenn etwas einen Fehler wirft, kann Check Output die Server- und Client-Zeilen deines letzten Playtests lesen. Die meisten Spielsysteme reden über Remotes wie diese, also begegnen sie dir wieder, wenn du mit RoCode ein Spiel System für System baust. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Was bedeutet „Securing the client-server boundary“ in Roblox?

Das ist der Name der Roblox-Doku-Seite zur Sicherheit von Remotes, und die Idee ist einfach: Alles, was ein Client über ein RemoteEvent oder eine RemoteFunction schickt, kann von einem Exploiter stammen, also prüft der Server es, bevor er handelt. Prüf den Typ jedes Arguments, halt Zahlen in einem vernünftigen Bereich, prüf, ob der Spieler das gerade tun darf, und begrenz, wie oft jeder Spieler feuern kann. Die Checkliste zur Prüfung oben zeigt jeden dieser Punkte im Code.

Sind RemoteFunctions sicher?

InvokeServer ist so sicher wie dein Server-Callback: Prüf seine Argumente und begrenz die Rate wie bei jedem RemoteEvent. InvokeClient ist die riskante Richtung, weil ein Client, der einen Fehler wirft, geht oder nie antwortet, den Aufruf des Servers kaputt macht oder einfriert.

Können Exploiter meine Remotes sehen und feuern?

Ja. Alles in ReplicatedStorage erreicht jeden Client, und ein manipulierter Client kann jedes Remote mit beliebigen Argumenten feuern. Remotes umzubenennen oder zu verstecken macht sie nicht sicher; jedes Argument auf dem Server zu prüfen schon.

Kann ein Client ein RemoteEvent an einen anderen Client schicken?

Nicht direkt. Feuere es an den Server, prüf es dort und nimm dann FireClient oder FireAllClients.

Wie oft kann ich ein RemoteEvent feuern?

Roblox dokumentiert ein Limit von etwa 500 Anfragen pro Sekunde pro Client für Nachrichten von RemoteEvents und UnreliableRemoteEvents an den Server, das sich alle Remotes desselben Typs teilen. Bleib weit darunter und gib jedem Handler sein eigenes Limit pro Spieler.

Erreicht FireAllClients Spieler, die später beitreten?

Nein. Es erreicht die Spieler, die in diesem Moment verbunden sind. Für Zustand, den Nachzügler brauchen, setz ein Attribut oder ein Value-Objekt auf dem Server.

Was ist der Unterschied zwischen einem RemoteEvent und einem BindableEvent?

Ein RemoteEvent überquert die Grenze zwischen Server und Client. Ein BindableEvent verbindet Skripte auf derselben Seite, etwa zwei Server-Scripts.

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, 12. 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.