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 (
InvokeServerundOnServerInvoke) nur, wenn der Client eine Antwort zurückbraucht. MeideInvokeClient: 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
- Warum es Remotes gibt
- Remotes einrichten
- 1. Client zum Server
- 2. Server zu einem Client
- 3. Server zu allen Clients
- RemoteFunctions
- Checkliste zur Prüfung
- Was sich nicht senden lässt
- Gibt nil zurück?
- UnreliableRemoteEvent
- Reihenfolge und Limits
- Was du nimmst
- Häufige Fehler
- Mit RoCode
- Häufige Fragen
- Quellen und weiterführende Links
Warum es RemoteEvents gibt
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.
| Richtung | Sender ruft auf | Empfänger verbindet sich mit | Empfänger bekommt |
|---|---|---|---|
| Client zum Server | remote:FireServer(...) in einem LocalScript | remote.OnServerEvent in einem Script | Den Player, der gefeuert hat, dann deine Argumente |
| Server zu einem Client | remote:FireClient(player, ...) in einem Script | remote.OnClientEvent in einem LocalScript | Nur deine Argumente |
| Server zu allen Clients | remote:FireAllClients(...) in einem Script | remote.OnClientEvent in einem LocalScript | Nur deine Argumente |
| Client fragt, Server antwortet | remoteFunction: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.
- Fahr im Explorer mit der Maus über ReplicatedStorage, klick auf den Button + und füge einen Folder ein. Nenn ihn
Remotes. - 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 BeispielPaintRequest. - Wiederhol das für jedes Remote. Dieser Guide nutzt zwei RemoteEvents (
PaintRequestundNotify) und eine RemoteFunction (RedeemCode).
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.
- Füge in Workspace einen Folder namens
Paintableein und leg ein paar verankerte Parts hinein. - Prüf, dass
ReplicatedStorage.Remotesein RemoteEvent namensPaintRequestenthält. - Füge in ServerScriptService ein Script namens
PaintServerein und unter StarterPlayer, StarterPlayerScripts ein LocalScript namensPaintClient, mit dem Code unten.
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.
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.
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
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.
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.
- Füge in
ReplicatedStorage.Remoteseine RemoteFunction namensRedeemCodeein. - Füge in StarterGui ein ScreenGui namens
CodeGuiein und darin eine TextBox namensCodeBox. Größe und Position wählst du, wie du magst. - Füge das Script unten in ServerScriptService ein und das LocalScript in
CodeBox.
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.
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
InvokeClienteinen 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.
| Prüfung | Die Frage, die der Server stellt | Beispiel |
|---|---|---|
| Typ | Ist es der Typ, den ich erwarte? Eine Instance, keine Tabelle, die nur so aussehen soll? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Bereich | Ist 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örigkeit | Besitzt 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 |
| Entfernung | Ist 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 |
| Rate | Sendet 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.
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:
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:
| Du sendest | Was passiert |
|---|---|
| Eine Funktion | Die andere Seite bekommt nil |
| Eine Tabelle mit Metatable | Die Metatable geht verloren, zusammen mit allem, was die Tabelle nur durch sie hatte |
| Eine Tabelle, die Zahlen-Keys und String-Keys mischt | Roblox rät davon ab: Sende ein reines Array oder ein reines Dictionary |
Eine Tabelle mit nil-Werten darin | Vermeiden: Roblox rät von nil an jedem Index ab |
| Eine Tabelle mit Instance-, userdata- oder Funktions-Keys | Diese Keys werden in Strings umgewandelt |
| Eine Instance, die der Empfänger nicht sehen kann, etwa eine in ServerStorage oder eine, die ein LocalScript erstellt hat | Die andere Seite bekommt nil |
| Irgendeine Tabelle | Der 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:
- Ein Pfad ohne Rückgabewert. Jeder Weg aus
OnServerInvokeheraus muss etwas zurückgeben. Ein nacktesreturnin einer frühen Prüfung schicktnilzurück. - Ein return in einer verschachtelten Funktion. Ein
returninpcall(function() ... end), einem:Connect-Handler odertask.spawnverlässt nur diese innere Funktion. Fang das Ergebnis auf, zum Beispiel mitlocal ok, data = pcall(...), und gib danndataaus dem Callback selbst zurück. - 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
nilan. Mit Instance Streaming hat ein Part, den der Server gerade erst erstellt hat, den Client vielleicht noch nicht erreicht, wenn die Funktion zurückkehrt. - Ein anderes Skript hat den Callback gesetzt. Nur die letzte Zuweisung an
OnServerInvokelä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.waitoderWaitForChild, 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?
| Nimm | Für | Beispiel | Achte auf |
|---|---|---|---|
| RemoteEvent | Nachrichten in eine Richtung, die ankommen müssen, in Reihenfolge | Client: „Färb diesen Part“. Server: „Zeig diesen Hinweis“ | Jedes Argument auf dem Server prüfen |
RemoteFunction mit InvokeServer | Der Client braucht eine Antwort, bevor er weitermachen kann | Einen Code einlösen, einen Kauf bestätigen | Der Aufrufer wartet; jeder Pfad muss einen Wert zurückgeben |
RemoteFunction mit InvokeClient | Fast nie | Nimm stattdessen FireClient | Ein Client, der einen Fehler wirft, geht oder nie antwortet, macht den Server-Aufruf kaputt oder friert ihn ein |
| UnreliableRemoteEvent | Häufige Updates, bei denen nur das neueste zählt | Zielrichtung, kosmetische Effekte | Nachrichten gehen verloren oder werden umsortiert; Nutzlast höchstens 1.000 Bytes |
| Attribut oder Value-Objekt, das der Server setzt | Gemeinsamer Zustand, der immer sichtbar sein soll, auch für Spieler, die später beitreten | Rundentimer, Spielphase, ob eine Tür offen ist | Nur Änderungen des Servers erreichen alle; Clients hören mit GetAttributeChangedSignal oder Changed |
| BindableEvent | Skripte auf derselben Seite, die miteinander reden | Ein 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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (auf Englisch). FireServer, FireClient, InvokeServer, Risiken von InvokeClient, Grenzen bei Argumenten und Zustellgarantien
- Roblox Creator Docs: Securing the client-server boundary (auf Englisch). Prüfschichten, NaN, Rate-Limits, Weiterleitungen von Client zu Client
- Roblox Creator Docs: Security and cheat mitigation tactics (auf Englisch). Was ein manipulierter Client tun kann, und die Autorität des Servers
- Roblox Creator Docs: Network ownership, movement validation, and physics (auf Englisch). Warum ein Client seinen eigenen Charakter steuert, und die Grenzen von Entfernungsprüfungen
- Roblox Engine API: RemoteEvent (auf Englisch). Drossel-Limit und der Fehler invocation discarded
- Roblox Engine API: RemoteFunction (auf Englisch). OnServerInvoke, Warnungen zu InvokeClient und Vorsicht bei Streaming
- Roblox Engine API: UnreliableRemoteEvent (auf Englisch). Das Limit von 1.000 Bytes Nutzlast
- Roblox Creator Docs: Properties and attributes (auf Englisch). Replikationsreihenfolge zwischen Eigenschaftsänderungen und Remote-Events
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.