Eğitim · Script temelleri

Roblox'ta RemoteEvent: client'tan sunucuya ve geri

Bir LocalScript diğer oyuncuların gördüğünü değiştiremez, sunucudaki bir Script de bir oyuncunun ekranına dokunamaz. RemoteEvent'ler ikisi arasında mesaj taşır. Bu rehber en çok kullanacağın üç kalıbı, cevap döndüren bir RemoteFunction'ı ve değiştirilmiş bir client'ın bunları kötüye kullanmasını engelleyen sunucu kontrollerini kuruyor.

Güncellendi: 20 Kasım 202615 dk okumaYazan:

Kısaca

RemoteEvent, client ile sunucu arasındaki sınırın üzerinden mesaj gönderen bir nesnedir ve genelde ReplicatedStorage'da durur. Bir LocalScript FireServer çağırır, sunucu da bunu OnServerEvent'te alır; gönderen Player ilk argüman olarak eklenir. Sunucu FireClient(player, ...) ya da FireAllClients(...) çağırır, LocalScript'ler de bunu OnClientEvent'te alır.

  • RemoteFunction'ı (InvokeServer ve OnServerInvoke) sadece client'ın bir cevaba ihtiyacı olduğunda kullan. InvokeClient'tan kaçın: hata veren, oyundan çıkan ya da hiç cevap vermeyen bir client sunucunun çağrısını bozar.
  • Bir client'ın gönderdiği hiçbir şeye güvenme. Sunucuda her argümanın türünü, aralığını ve sahipliğini, oyuncunun mesafesini ve ne sıklıkla gönderdiğini kontrol et.
  • Fonksiyonlar, metatable'lar ve karşı tarafın göremediği nesneler yolculuktan sağ çıkmaz. Bir UnreliableRemoteEvent mesajları kaybedebilir ya da sırasını karıştırabilir ve 1000 bayttan büyük her yükü atar.
Bu sayfada
  1. Neden var
  2. Remote'ları hazırlamak
  3. 1. Client'tan sunucuya
  4. 2. Sunucudan bir client'a
  5. 3. Sunucudan herkese
  6. RemoteFunction
  7. Doğrulama listesi
  8. Neler gönderilemez
  9. Nil mi dönüyor?
  10. UnreliableRemoteEvent
  11. Sıra ve sınırlar
  12. Hangisini kullanmalı
  13. Sık hatalar
  14. RoCode ile
  15. Sık sorulan sorular
  16. Kaynaklar ve ek okumalar

RemoteEvent'ler neden var

ÇizimHer tıklama sunucudan parçayı boyamasını istiyor, bu yüzden iki oyuncunun ekranı da yeni rengi gösteriyor.

Her Roblox oyunu bir sunucu artı oyuncu başına bir client olarak çalışır. Otorite sunucudadır: yeni bir nesne ya da bir özellik değişikliği ancak sunucu yaptığında tüm oyunculara ulaşır. Bir LocalScript'te yapılan değişiklik o cihazda kalır; birkaç istisna var, mesela hareketini kendi client'ının kontrol ettiği oyuncunun kendi karakteri. Yani bir tıklama ya da tuş ortak dünyayı değiştirmeliyse client bunu sunucudan istemek zorunda, sunucu da bir oyuncunun ekranının tepki vermesini istediğinde bunu o client'a söylemek zorunda. Script ile LocalScript arasındaki fark sana yeniyse önce Script vs LocalScript vs ModuleScript (İngilizce) rehberini oku. Script yazmak yeniyse Roblox Studio'da script yazmayla başla.

Roblox bu sınırı geçmek için sana üç nesne veriyor:

  • RemoteEvent: tek yönlü bir mesaj. Gönderen hemen devam eder.
  • RemoteFunction: cevap bekleyen bir istek. Çağıran, karşı taraf bir değer döndürene kadar durur.
  • UnreliableRemoteEvent: daha az ağ yükü karşılığında kaybolabilen ya da sırası karışık gelebilen tek yönlü bir mesaj. Sürekli değişen veriler için.
Hangi çağrı hangi event'i tetikler
YönGönderen şunu çağırırAlıcı şuna bağlanırAlıcı şunu alır
Client'tan sunucuyaBir LocalScript'te remote:FireServer(...)Bir Script'te remote.OnServerEventGönderen Player, sonra senin argümanların
Sunucudan bir client'aBir Script'te remote:FireClient(player, ...)Bir LocalScript'te remote.OnClientEventSadece senin argümanların
Sunucudan tüm client'laraBir Script'te remote:FireAllClients(...)Bir LocalScript'te remote.OnClientEventSadece senin argümanların
Client sorar, sunucu cevaplarremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Player, sonra senin argümanların. Çağıran, fonksiyonun döndürdüğü şeyi alır

Client'lar birbirine doğrudan mesaj gönderemez. Bir şeyi bir oyuncudan diğerlerine iletmek için onu sunucuya gönder, orada kontrol et ve sunucunun FireClient ya da FireAllClients ile tekrar göndermesine izin ver. Roblox'un güvenlik rehberi burada sunucunun basit bir aktarıcı değil, bir kapı bekçisi gibi davrandığını söylüyor.

Remote'larını nereye koyacaksın

Bir remote hem sunucunun hem client'ların görebileceği bir yerde olmalı. Alışılmış yer ReplicatedStorage; Roblox dokümantasyonu bazı durumlarda Workspace'in ya da bir Tool'un da uygun olabileceğini belirtiyor. ServerStorage ve ServerScriptService sadece sunucuya ait, yani orada bir remote bekleyen LocalScript sonsuza kadar bekler.

  1. Explorer'da fareyle ReplicatedStorage üzerine gel, + butonuna tıkla ve bir Folder ekle. Adını Remotes koy.
  2. Fareyle Remotes üzerine gel, +'ya tıkla ve bir RemoteEvent ekle. Ne işe yaradığını anlatan bir ad ver, mesela PaintRequest.
  3. Her remote için tekrarla. Bu rehber iki RemoteEvent (PaintRequest ve Notify) ve bir RemoteFunction (RedeemCode) kullanıyor.
Explorer: bu rehberin bölüm bölüm eklediği her şey
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

Bu rehberdeki scriptler remote'ları WaitForChild ile bulur. Remote zaten oradaysa onu hemen döndürür, değilse bekler; mesela oyun çalışırken remote'ları bir sunucu scripti oluşturuyorsa. Her istek türü için bir remote kullan: böylece her sunucu handler'ı tek bir argüman biçimini kontrol eder, bu da her şeyi yapan tek bir remote'u doğru yapmaktan çok daha kolay.

Kalıp 1: client'tan sunucuya, sunucu kontrol eder

En yaygın iş: oyuncu kendi ekranında bir şey yapar, ne olacağına sunucu karar verir. Burada oyuncu dört renkten birini seçmek için Q'ya basıyor ve boyamak için bir parçaya tıklıyor ya da dokunuyor. Herkes yeni rengi görür, çünkü boyayan sunucu.

Client iki şey gönderir: hangi parça ve bir renk numarası. Rengin kendisini asla göndermez; başka oyunlarda da asla bir fiyat, bir ödül ya da bir hasar miktarı göndermemeli. Değiştirilmiş bir client her şeyi gönderebilir, bu yüzden gerçek verileri (burada palet) sunucu tutar ve argümanları kontrol edilmesi gereken bir istek olarak görür.

  1. Workspace'te Paintable adında bir Folder ekle ve içine birkaç anchored Part koy.
  2. ReplicatedStorage.Remotes içinde PaintRequest adında bir RemoteEvent olduğunu kontrol et.
  3. Aşağıdaki kodla ServerScriptService'e PaintServer adında bir Script, StarterPlayer, StarterPlayerScripts'e de PaintClient adında bir LocalScript ekle.
Script konum: ServerScriptService adı: 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")

-- Renklerin sahibi sunucu. Client sadece birini seçen bir numara gönderir.
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 -- karakter ile parça arasındaki stud
local COOLDOWN_SECONDS = 0.25

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

-- İlk parametre her zaman event'i gönderen oyuncudur. Onu Roblox doldurur,
-- yani güvenilir. Ondan sonra gelen her şey client'tan geldi ve güvenilir değil.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Tür: gerçek bir parça, parça gibi davranan bir tablo değil
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Aralık: 1'den 4'e bir tam sayı. NaN ve sonsuz da burada takılır.
	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. İzin verilen hedef: sadece Paintable klasöründeki parçalar, oyundaki başka hiçbir şey değil
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Mesafe: oyuncunun karakteri parçaya yakın olmalı
	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. Sıklık sınırı: oyuncu başına çeyrek saniyede bir boyama
	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)

Başarısız olan her kontrol sadece return yapar. Hile yapan bir client'a neden reddedildiğini söylemeye gerek yok.

LocalScript konum: StarterPlayerScripts adı: 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 -- gerçek renkler sunucuda
local selectedColour = 1

-- Işın sadece Paintable klasörünün içindeki parçalara çarpsın
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- tuş ya da tıklama sohbete ya da bir butona gitti
	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
			-- Emretme, iste: boyanıp boyanmayacağına sunucu karar verir
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed, motor girdiye zaten tepki verdiyse true olur; genelde UI'da: bir butona tıklama ya da sohbet çubuğu gibi bir metin kutusuna yazılan tuşlar. Bunu kontrol etmek, bir mesajda Q yazmanın rengi değiştirmemesini sağlar.

Kalıp 2: sunucudan bir client'a

Sunucu bir oyuncuya FireClient ile mesaj gönderir. İlk argüman mesajın gittiği Player'dır, client'taki handler da sadece ondan sonraki argümanları alır. Bunu kişisel olan her şey için kullan: bir bildirim, bir ödül penceresi, sadece o oyuncunun duyması gereken bir ses. Ara sahne rehberi daha büyük bir örnek: bir oyuncunun ara sahneyi ne zaman göreceğine sunucu karar veriyor ve çekimlerini FireClient ile o oyuncuya gönderiyor, kamerayı da oyuncunun cihazı hareket ettiriyor.

Bu ikili bir oyuncu girdiğinde bir hoş geldin mesajı gösteriyor. LocalScript kendi küçük yazısını kendisi kuruyor, yani hazırlanacak bir GUI yok.

Script konum: ServerScriptService adı: WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local function welcome(player: Player)
	-- İlk argüman hangi client'ın alacağını seçer. Bunu başka kimse görmez.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- Studio'da bu script bağlanmadan önce oyuna girebilirsin, o yüzden zaten burada olanları da selamla
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript konum: StarterPlayerScripts adı: NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Ekranın üstünde kodla yapılmış küçük bir yazı
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

-- Burada oyuncu parametresi yok: kimin alacağını sunucu zaten seçti
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 -- daha yeni bir mesaj yerini almadıysa gizle
			label.Visible = false
		end
	end)
end)

Sunucu PlayerAdded'da gönderiyor ve bu, bu LocalScript handler'ını bağlamadan önce olabilir. Sorun değil: Roblox, handler yokken gelen RemoteEvent mesajlarını sıraya koyar ve bir handler bağlanınca onları sırayla teslim eder.

Client'ın sunucudan korunmasına gerek yok: OnClientEvent'i sadece sunucu kodu tetikleyebilir. message: string açıklaması tür denetleyicisi içindir; çalışma anında bir kontrol değildir.

Kalıp 3: sunucudan tüm client'lara

FireAllClients aynı mesajı bağlı tüm oyunculara gönderir. Player argümanı almaz ve her client onu önceki OnClientEvent'te alır, yani kalıp 2'deki NotifyClient scripti onu zaten gösterir.

Bu Script, bir oyuncu bitiş çizgisine ilk kez dokunduğunda herkese duyuru yapar. Workspace'e FinishLine adında anchored bir Part ekle, sonra Script'i ServerScriptService'e ekle.

Script konum: ServerScriptService adı: 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 -- oyuncu değil ya da zaten duyuruldu
	end
	finished[player] = true

	-- Bağlı her client OnClientEvent handler'ını bu metinle çalıştırır
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

Bir exploiter kendi karakteri için Touched'ı her mesafeden tetikleyebilir; oyuncu başına bir kez gösterilen bir duyuru için bu zararsız. İleride bitişe ulaşmak için ödül verirsen, ödemeden önce sunucuda kontroller ekle, mesela turun başlamasından beri geçen en kısa süre.

FireAllClients sadece o anda bağlı olan oyunculara ulaşır. Bir saniye sonra giren biri mesajı hiç görmez. Bu bir duyuru, bir patlama efekti ya da bir ses gibi tek seferlik anlar için iyi, ama bir tur sayacı ya da oyunun mevcut aşaması gibi bir durum için kötü. Durum için sunucuda bir attribute ayarla, mesela ReplicatedStorage:SetAttribute("TimeLeft", 30), ve client'ta onu GetAttribute ve GetAttributeChangedSignal("TimeLeft") ile oku. Attribute'lar sonradan girenler de dahil tüm client'lara replike edilir.

RemoteFunction: client'ın bir cevaba ihtiyacı olduğunda

Bir RemoteEvent gönderilir ve unutulur. Bir RemoteFunction ise çağıranı bekletir: InvokeServer, onu çağıran kodu sunucudaki OnServerInvoke fonksiyonu bir değer döndürene kadar durdurur, sonra döndürülen şeyi teslim eder. Client cevap olmadan devam edemiyorsa kullan, mesela "bu kod geçerli miydi?". Cevaba ihtiyacın yoksa Roblox RemoteEvent öneriyor, çünkü beklemez.

Örnek: oyuncuların bir ödül kodu yazdığı bir kutu. Kodları sunucu tutar, metni kontrol eder ve iki değer döndürür: işe yarayıp yaramadığı ve gösterilecek bir mesaj.

  1. ReplicatedStorage.Remotes içine RedeemCode adında bir RemoteFunction ekle.
  2. StarterGui'ye CodeGui adında bir ScreenGui, içine de CodeBox adında bir TextBox ekle. Boyutunu ve konumunu istediğin gibi ayarla.
  3. Aşağıdaki Script'i ServerScriptService'e, LocalScript'i de CodeBox'ın içine ekle.
Script konum: ServerScriptService adı: RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Kodlar sunucuda yaşar, hiçbir oyuncunun okuyamayacağı yerde
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 } = {}

-- = ile ata. OnServerInvoke bir callback, Connect ile bağlandığın bir event değil.
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)

Leaderboard rehberindeki Coins istatistiğine ekler. Kullanılan kodlar sadece oyuncu çıkana kadar hatırlanır, yani bu haliyle bir oyuncu tekrar girip aynı kodu yeniden kullanabilir. Coin'ler kaydediliyorsa bu her girişte bedava coin demek: canlı bir oyunda kullanmadan önce her oyuncunun kullandığı kodları kayıtlı verileriyle birlikte bir data store'a kaydet.

LocalScript konum: CodeBox TextBox adı: 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, sunucunun callback'i bir değer döndürene kadar bu fonksiyonu durdurur.
	-- Çağrı başarısız olursa pcall LocalScript'in çalışmaya devam etmesini sağlar.
	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)

Bir RemoteFunction'ın tam olarak bir sunucu callback'i vardır. İki script aynı RemoteFunction'da OnServerInvoke atarsa sadece sonuncusu çalışır.

InvokeClient neden riskli

Bir RemoteFunction öbür yönde de çalışır: sunucuda InvokeClient, client'ta OnClientInvoke ile. Roblox dokümantasyonu üç ciddi risk sayıyor:

  • Client'ın callback'i hata verirse sunucu da hata verir.
  • Oyuncu çağrılırken oyundan çıkarsa InvokeClient hata verir.
  • Client hiç değer döndürmezse sunucu scripti sonsuza kadar bekler.

Değiştirilmiş bir client kendi callback'ini kontrol eder, yani hile yapan biri üçüncüsünü bilerek tetikleyip o sunucu thread'ini istediği kadar tutabilir. Bir oyuncunun ekranını güncellemek için FireClient kullan. Sunucunun gerçekten bir client'tan bilgiye ihtiyacı varsa bir RemoteEvent gönder, client başka bir RemoteEvent üzerinden cevap versin ve cevap gelmemesini sunucuda normal bir durum olarak ele al.

Her argümanı sunucuda doğrula

Bir exploiter herhangi bir RemoteEvent'i gönderebilir ya da herhangi bir RemoteFunction'ı çağırabilir, istediği kadar ve istediği argümanlarla. Taklit edemediği tek şey ilk parametre: gönderen Player'ı Roblox doldurur. Ondan sonra gelen her şey sunucu harekete geçmeden önce kontrol edilmeli. Remote'u gizlemek ya da LocalScript'te kontrol etmek işe yaramaz, çünkü hile yapan kendi client'ını kontrol ediyor.

Sunucu kontrolleri listesi
KontrolSunucunun sorduğu soruÖrnek
TürBeklediğim türde mi? Ona benzemek için yapılmış bir tablo değil de bir Instance mı?typeof(part) == "Instance" and part:IsA("BasePart")
AralıkSayı sonlu ve izin verilen aralıkta mı? Metnin uzunluğu makul mü?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
SahiplikBu oyuncu nesnenin sahibi mi, parası var mı, bu nesne üzerinde işlem yapma hakkı var mı?Nesne envanterinde; parça Paintable'ın içinde
MesafeOyuncunun karakteri, dünyanın sunucudaki kopyasında yeterince yakın mı? Lag için biraz pay bırak.Parçaya 30 stud'dan yakın
SıklıkBu oyuncu çok hızlı mı gönderiyor?Oyuncu başına bir bekleme süresi ya da dolan bir çağrı hakkı

NaN ayrı bir uyarıyı hak ediyor. Bir sayı olduğu için type(x) == "number" geçer, ama onunla her karşılaştırma false olur, yani x < 0 or x > 100 gibi bir kontrol onu doğrudan geçirir. math.isfinite(x) NaN'ı ve iki sonsuzu reddeder.

Mesafe kontrolünün sınırını bil. Her client kendi karakterinin fiziğini kontrol eder, yani bir exploiter göndermeden önce karakterini hedefin yanına taşıyabilir. Yine de kontrol, tek bir noktadan tüm haritada işlem yapma gibi kolay kötüye kullanımı engeller. Hedef parçaları da anchored tut: Roblox güvenlik dokümantasyonu, bir exploiter'ın yakınındaki anchored olmayan parçaların ağ sahipliğini alıp onları yaklaştırabileceğini belirtiyor; bu da mesafe kontrolünü atlatır.

İşte aynı kontroller, her remote handler'ında tekrar kullanabileceğin bir ModuleScript olarak.

ModuleScript konum: ServerScriptService adı: RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- min ile max arasında gerçek bir sayı. Basit bir type(x) == "number" kontrolünü
-- geçen NaN'ı ve sonsuzu reddeder.
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

-- min ile max arasında bir tam sayı; sayılar, indeksler ve miktarlar için
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

-- Uzunluk sınırı olan metin. utf8.len geçersiz UTF-8'de nil döndürür, onu da
-- data store'lar reddeder.
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

-- Beklenen sınıftan, izin verdiğin konteynerin içinde bir Instance.
-- Instance gibi görünmek için yapılmış bir tablo typeof kontrolünde takılır.
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

-- Oyuncunun karakteri position'a maxDistance stud ya da daha yakınsa true
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

-- Oyuncu başına bir sıklık sınırı. Her oyuncu bir seferde `burst` çağrı yapabilir ve
-- her saniye `perSecond` çağrı geri kazanır. İşi yapmadan önce çağrılan bir
-- fonksiyon döndürür: true (devam) ya da false (çok hızlı) cevabını verir.
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

ServerScriptService'te bırak. Oradaki kod asla client'lara ulaşmaz, yani kontrollerini kimse okuyamaz.

Ve işte kalıp 1'deki handler, bununla yeniden yazılmış hali. PaintServer'ın içeriğini değiştir:

Script konum: ServerScriptService adı: PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" sadece Luau'nun katı tür denetleyicisini ilgilendirir; çalışırken hiçbir şeyi değiştirmez
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) -- 4'lük bir seri, sonra saniyede 4

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)

Sınırlayıcı her oyuncunun kaydını oyuncu çıkınca siler, yani tablosu sunucunun ömrü boyunca büyümez.

Bu kontrollerin en çok önemli olduğu yer silahlar: kime vurduğunu asla client'ın söylemesine izin verme. Kılıç rehberindeki remote hiç argüman almaz, hedefleri sunucu kendisi bulur. Silah rehberi (İngilizce) sadece bir nişan noktası gönderir, sunucu da kendi ışınını atmadan önce onun türünü, NaN'ı ve mesafeyi kontrol eder.

Menüler de aynı kurala uyar: sonucu değil, bir seçimi gönder. NPC diyalog rehberinde client sadece basılan butonun numarasını gönderir, o cevabın ne verdiğine de sunucu bakar. Işınlanma rehberindeki menü bir konum değil, bir noktanın adını gönderir; sunucu noktayı kendi klasöründe arar ve gereken Wins'i kontrol eder.

Neyi gönderebilir, neyi gönderemezsin

Sayılar, string'ler, boolean'lar, Vector3, CFrame, Color3 gibi Roblox türleri ve Enum öğeleri, iki tarafın da görebildiği Instance'lar ve bunların hepsinden oluşan tablolar gönderebilirsin. Bazı değerler yolda değişir ya da kaybolur:

Gönderildiği gibi ulaşmayan argümanlar
GönderdiğinNe olur
Bir fonksiyonKarşı taraf nil alır
Metatable'ı olan bir tabloMetatable kaybolur, tablonun sadece onun sayesinde sahip olduğu her şeyle birlikte
Sayısal anahtarlarla metin anahtarlarını karıştıran bir tabloRoblox bunu yapma diyor: saf bir dizi ya da saf bir sözlük gönder
İçinde nil değerler olan bir tabloBundan kaçın: Roblox hiçbir indekste nil önermiyor
Anahtarları Instance, userdata ya da fonksiyon olan bir tabloBu anahtarlar string'e dönüşür
Alıcının göremediği bir Instance, mesela ServerStorage'daki ya da bir LocalScript'in oluşturduğu biriKarşı taraf nil alır
Herhangi bir tabloAlıcı bir kopya alır, asla aynı tabloyu değil

İyi bir alışkanlık, nesne ya da değer yerine tanımlayıcı göndermek: bir nesnenin adı, bir seçeneğin indeksi, sunucunun bulup kontrol edebileceği bir parça. Böylece sunucu kendi verileriyle çalışır.

RemoteFunction neden nil döndürüyor

InvokeServer sana nil veriyorsa sırayla şunlara bak:

  1. Dönüş değeri olmayan bir yol. OnServerInvoke'tan her çıkış bir şey döndürmeli. Erken bir kontroldeki yalın bir return, nil döndürür.
  2. İç içe bir fonksiyondaki return. pcall(function() ... end), bir :Connect handler'ı ya da task.spawn içindeki bir return sadece o iç fonksiyondan çıkar. Sonucu yakala, mesela local ok, data = pcall(...), sonra data'yı callback'in kendisinden döndür.
  3. Sınırı geçemeyen bir değer. Bir fonksiyon ya da client'ın göremediği bir Instance (mesela ServerStorage'daki her şey) nil olarak gelir. Instance streaming açıksa, sunucunun az önce oluşturduğu bir parça, fonksiyon değeri döndürdüğünde henüz client'a ulaşmamış olabilir.
  4. Callback'i başka bir script atadı. OnServerInvoke'a sadece son atama çalışır. Remote'un adını scriptlerinde ara.

Çağrı hiç geri dönmüyorsa ya henüz hiçbir script OnServerInvoke atamamıştır (Roblox, biri atayana kadar çağrıları sıraya koyar) ya da callback takılmıştır, mesela hiç ortaya çıkmayan bir şeyin WaitForChild'ında.

UnreliableRemoteEvent: sürekli ve atılabilir güncellemeler için

Bir UnreliableRemoteEvent'in RemoteEvent ile aynı metotları ve event'leri vardır: FireServer, FireClient, FireAllClients, OnServerEvent ve OnClientEvent. Fark şu: Roblox ne teslimatı ne de sırayı garanti eder. Bir mesaj şu durumlarda yeniden gönderilmeden kaybolabilir:

  • yolda kaybolursa ya da sıkışık bir ağda çok uzun beklerse
  • yükü 1000 bayttan büyükse
  • bir client sıklık sınırından hızlı gönderirse (fazlası atılır, ertelenmez)
  • geldiğinde bağlı bir handler yoksa (atılır, sıraya konmaz)

Mesajlar sırası karışık da gelebilir ve RemoteEvent'lerinle ya da RemoteFunction'larınla hiçbir sıra ilişkisi yoktur. Sadece en yeni değerin önemli olduğu ve bir sonraki güncellemenin saniyenin bir kesrinde geldiği durumlarda kullan: bir oyuncunun nereye nişan aldığı, kozmetik bir efektin konumu, her karede değişen bir değer. Sıra önemliyse her mesaja bir sıra numarası ya da zaman damgası koy ve işlediğin sonuncudan eski olan her şeyi görmezden gel.

Bir satın alma, hasar, bir ödül ya da bir turun başlaması gibi tam olarak bir kez olması gereken hiçbir şey için asla kullanma. Argümanlarını da sunucuda tıpkı bir RemoteEvent'teki gibi doğrula.

Teslim sırası ve sıklık sınırları

Roblox'un teslim garantileri tek yöndeki bir bağlantı için geçerli: sunucudan bir client'a ya da bir client'tan sunucuya.

  • RemoteEvent'ler güvenilir ve sıralıdır. Kaybolan mesajlar alıcı bağlı kaldığı sürece yeniden gönderilir ve mesajlar, farklı RemoteEvent'ler arasında bile, gönderdiğin sırayla gelir. Sunucu bir oyuncuya A, sonra B, sonra A gönderirse o oyuncu A, B, A alır.
  • Sıra, handler'ların ne zaman başladığıyla ilgili. Bir handler kontrolü bırakırsa, mesela task.wait ya da WaitForChild ile, bir sonraki mesajın işlenmesi ilki bitmeden başlayabilir.
  • RemoteFunction'lar ve RemoteEvent'ler birbirine göre sıralı değil. Kodun kesin bir sıraya bağlıysa, ilgili mesajları aynı türden remote üzerinden gönder ya da kendi sıra numaranı ekle.
  • Özellik ve attribute değişiklikleri remote'lara göre sıralı değil. Sunucu bir özelliği değiştirip sonra bir remote gönderirse client ikisinden herhangi birini önce görebilir. Değişikliğin geldiğini varsaymak yerine değişikliğin kendisini dinle, mesela GetPropertyChangedSignal ile.
  • Henüz handler yok. RemoteEvent mesajları bir handler bağlanana kadar sıraya konur. Sıranın sınırları var: dolduğunda sonraki mesajlar atılır ve Output'ta Remote event invocation discarded hatası görünür.
  • Oyundan çıkan bir oyuncu kendisine henüz ulaşmamış mesajları kaybeder.

Sıklık sınırı. Bir client'tan sunucuya giden RemoteEvent ve UnreliableRemoteEvent mesajları, 30 Eylül 2026 itibarıyla dokümantasyona göre client başına saniyede yaklaşık 500 istekle sınırlı. Sınırı aynı türdeki tüm remote'lar paylaşır, yani çok kullanılan bir remote'u ona bölmek sınırı artırmaz. Sınır aşılınca RemoteEvent mesajları daha sonra işlenir ve sıralarını korur, UnreliableRemoteEvent mesajları ise atılır. Motorun sınırı, bir oyuncunun remote'unu saniyede 50 kez göndermesini engellemek için hiçbir şey yapmaz, yani bir şeyi değiştiren her handler'ın yine oyuncu başına kendi sınırına ihtiyacı var.

RemoteEvent mi, RemoteFunction mı, UnreliableRemoteEvent mi, attribute mu?

Client ile sunucunun nasıl konuşacağını seçmek
KullanNe içinÖrnekDikkat et
RemoteEventUlaşması gereken, sıralı tek yönlü mesajlarClient: "bu parçayı boya". Sunucu: "bu bildirimi göster"Her argümanı sunucuda doğrula
InvokeServer ile RemoteFunctionClient devam edebilmek için bir cevaba ihtiyaç duyuyorBir kodu kullanmak, bir satın almayı onaylamakÇağıran bekler; her yol bir değer döndürmeli
InvokeClient ile RemoteFunctionNeredeyse hiçbir zamanBunun yerine FireClient kullanHata veren, oyundan çıkan ya da hiç cevap vermeyen bir client sunucunun çağrısını bozar ya da dondurur
UnreliableRemoteEventSadece sonuncusunun önemli olduğu sık güncellemelerNişan yönü, kozmetik efektlerKaybolan ya da sırası karışan mesajlar; 1000 baytlık yük sınırı
Sunucunun ayarladığı attribute ya da value nesnesiHer zaman görünür olması gereken ortak durum, sonradan girenler için deTur sayacı, oyun aşaması, bir kapının açık olup olmadığıSadece sunucunun değişiklikleri herkese ulaşır; client'lar GetAttributeChangedSignal ya da Changed ile dinler
BindableEventAynı taraftaki scriptlerin birbiriyle konuşmasıBir sunucu scriptinin diğerine turun bittiğini haber vermesiSunucu ile client arasında geçmez

RemoteFunction'ların ve doğrulamanın, oyuncuların para ödediği bir şeyde birlikte çalıştığı tam bir örnek için mağaza GUI'si yapmaya bak. Attribute satırı için, kapı rehberinin sunucu scripti her kapı hareket ettiğinde ona bir Open attribute'u koyar, yani her LocalScript buna tepki verebilir.

Sık karşılaşılan hatalar ve çözümleri

Remote sorunlarının çoğu Output penceresinde görünür (Window menüsünden ya da Script sekmesinden aç). Önce oraya bak, sonra belirtiyi aşağıda ara. Script hataları rehberi genel hata mesajlarını daha ayrıntılı anlatıyor.

Bir remote'un WaitForChild'ında Infinite yield possible

Bir script hiç gelmeyen bir remote'u bekliyor. Adın ve büyük küçük harflerin tam olarak eşleştiğini, remote'un da client'ların göremediği ServerStorage ya da ServerScriptService'te değil, ReplicatedStorage'da olduğunu kontrol et.

Sunucu bir sıra kaymış yanlış değerler alıyor

LocalScript oyuncunun kendisini geçti, remote:FireServer(player, 5) gibi. Roblox göndereni zaten ilk parametre olarak ekler, yani sunucu (player, player, 5) görür. remote:FireServer(5) çağır.

Remote'u gönderdiğimde hiçbir şey olmuyor

Her çağrının doğru tarafta çalıştığını kontrol et: FireServer ve InvokeServer sadece client kodundan, FireClient, FireAllClients ve InvokeClient de sadece sunucudaki bir Script'ten çalışır. Bir LocalScript ServerScriptService'te, ServerStorage'da ya da doğrudan Workspace'te asla çalışmaz; onu StarterPlayerScripts'e, StarterGui'ye, StarterCharacterScripts'e ya da StarterPack'e koy. Sonra Output'ta handler'ın içinde bir hata ara.

Remote event invocation discarded

Bağlı hiçbir handler'ı olmayan bir RemoteEvent'e mesajlar geldi ve sıra doldu. Genelde handler'ın scripti :Connect satırından önce hata veriyor, devre dışı ya da hiç yüklenmeyen bir şeyi beklerken takılmış. Handler'ları scriptin başına yakın bağla.

Bende çalışıyor ama diğer oyuncular değişikliği görmüyor

Değişiklik client'ta, bir LocalScript'te ya da bir OnClientEvent handler'ında yapıldı. Onu sunucudaki OnServerEvent handler'ında yap.

InvokeServer hiç geri dönmüyor

Ya hiçbir script OnServerInvoke atamadı (Roblox biri atayana kadar çağrıları sıraya koyar) ya da callback, WaitForChild ya da bir data store isteği gibi kontrolü bırakan bir şeyde takıldı. Nerede durduğunu görmek için callback'in başına ve sonuna bir print ekle.

RoCode ile kur

Bunu açık olan place'inde RoCode'a da kurdurabilirsin. RoCode, bir Roblox Studio plugin'i üzerinden çalışan bir yapay zeka ajanı, yani sana yapıştıracağın kod vermek yerine remote'ları ve scriptleri Explorer'ında oluşturur.

Sen yazarsın

Oyuncular Paintable klasöründeki parçalara tıklayarak onları boyayabilsin. Bir RemoteEvent kullan ve kontrolleri sunucuda tut: sadece o klasördeki parçalar, 30 stud'dan yakın ve saniyede birkaç boyamadan fazla değil.

RoCode yapar
  • Genelde önce Search Game ve Search Scripts ile place'e bakar, var olan bir Remotes klasörü ya da handler arar ve klasörlerin zaten oradaysa onları kullanır
  • RemoteEvent'i Create Instance ile ReplicatedStorage'da oluşturur, sunucu Script'ini ve LocalScript'i de Create Script ile yazar
  • Bitirmeden önce her scriptin derlendiğini Studio içinde Check Script ile kontrol eder. Bu, mantık hatalarını değil derleme hatalarını yakalar: tür denetimi yapmaz, lint yapmaz ve kodunu çalıştırmaz
  • Değişikliklerini gruplar halinde gönderir ve her grup Studio geçmişinde bir geri alma noktasıdır

Plugin 3.9 ya da üstüyle RoCode kısa bir test yapıp hataları okuyabilir, plugin 3.9.11 ya da üstüyle de bir test karakterini yönetebilir, ama 3D görünümde parçalara tıklamaz. Play'e kendin bas ve kontrolleri bozmayı dene, mesela haritanın öbür ucundan boyayarak. Bir şey hata verirse Check Output son oyun testinin Server ve Client satırlarını okuyabilir. Bir oyunun sistemlerinin çoğu bunun gibi remote'lar üzerinden konuşur, yani RoCode ile bir oyunu sistem sistem kurduğunda yine karşına çıkarlar. RoCode Studio'ya nasıl bağlanır.

Sık sorulan sorular

Roblox'ta client ile sunucu arasındaki sınırı güvenli hale getirmek ne demek?

Bu, Roblox dokümantasyonunun remote güvenliği hakkındaki sayfasının adı ve fikir basit: bir client'ın bir RemoteEvent ya da RemoteFunction üzerinden gönderdiği her şey bir exploiter'dan gelebilir, bu yüzden sunucu harekete geçmeden önce onu kontrol eder. Her argümanın türünü kontrol et, sayıları makul bir aralıkta tut, oyuncunun bunu şu anda yapmaya izni olduğunu kontrol et ve her oyuncunun ne sıklıkla gönderebileceğini sınırla. Yukarıdaki doğrulama listesi bunların her birini kodda gösteriyor.

RemoteFunction kullanmak güvenli mi?

InvokeServer sunucu callback'in kadar güvenli: argümanlarını doğrula ve sıklığını herhangi bir RemoteEvent'teki gibi sınırla. Riskli yön InvokeClient, çünkü hata veren, oyundan çıkan ya da hiç cevap vermeyen bir client sunucunun çağrısını bozar ya da dondurur.

Exploiter'lar remote'larımı görüp gönderebilir mi?

Evet. ReplicatedStorage'daki her şey tüm client'lara ulaşır ve değiştirilmiş bir client her remote'u her argümanla gönderebilir. Remote'ların adını değiştirmek ya da onları gizlemek onları güvenli yapmaz; her argümanı sunucuda kontrol etmek yapar.

Bir client başka bir client'a RemoteEvent gönderebilir mi?

Doğrudan değil. Onu sunucuya gönder, orada kontrol et, sonra FireClient ya da FireAllClients kullan.

Bir RemoteEvent'i ne sıklıkla gönderebilirim?

Roblox, sunucuya gönderilen RemoteEvent ve UnreliableRemoteEvent mesajları için client başına saniyede yaklaşık 500 isteklik bir sınır belgeliyor; bu sınırı aynı türdeki tüm remote'lar paylaşıyor. Bunun çok altında kal ve her handler'a oyuncu başına kendi sınırını ver.

FireAllClients sonradan giren oyunculara ulaşır mı?

Hayır. O anda bağlı olan oyunculara ulaşır. Geç girenlerin ihtiyaç duyduğu bir durum için sunucuda bir attribute ya da value nesnesi ayarla.

RemoteEvent ile BindableEvent arasındaki fark ne?

Bir RemoteEvent sunucu ile client arasında geçer. Bir BindableEvent ise iki sunucu scripti gibi aynı taraftaki scriptleri bağlar.

Kaynaklar ve ek okumalar

Kod nasıl kontrol edildi: bu sayfadaki her script, Roblox API tanımlarıyla Luau'nun katı tür denetleyicisinden geçiyor (luau-lsp, 20 Kasım 2026). Tür denetimi yanlış yazılmış API'leri ve hatalı türleri yakalar, oyun mantığını değil. Bu yüzden yayınlamadan önce Studio'da test et.

RoCode'u kendi oyununda dene.

Her gün ücretsiz kredi, kart gerekmez. Plugin'i kur, özelliği anlat ve Studio'da ne oluştuğunu kontrol et.