Οδηγός · Βασικά του scripting

RemoteEvent στο Roblox: από τον client στον server και πίσω

Ένα LocalScript δεν μπορεί να αλλάξει αυτό που βλέπουν οι άλλοι παίκτες, και ένα Script του server δεν μπορεί να φτάσει στην οθόνη ενός μόνο παίκτη. Τα μηνύματα ανάμεσά τους τα μεταφέρουν τα RemoteEvent. Σε αυτόν τον οδηγό φτιάχνουμε τα τρία μοτίβα που θα χρειάζεστε πιο συχνά, ένα RemoteFunction που επιστρέφει απάντηση, και τους ελέγχους στον server που δεν αφήνουν έναν τροποποιημένο client να τα εκμεταλλευτεί.

Ενημερώθηκε 20 Νοεμβρίου 202620 λεπτά ανάγνωσηςΣυντάκτης:

Με λίγα λόγια

Το RemoteEvent είναι ένα αντικείμενο που συνήθως βρίσκεται στο ReplicatedStorage και μεταφέρει μηνύματα πάνω από το όριο ανάμεσα σε client και server. Ένα LocalScript καλεί FireServer, και ο server λαμβάνει το μήνυμα στο OnServerEvent, με τον Player που το έστειλε προστεθειμένο ως πρώτο όρισμα. Ο server καλεί FireClient(player, ...) ή FireAllClients(...), και τα LocalScripts λαμβάνουν το μήνυμα στο OnClientEvent.

  • Χρησιμοποιήστε RemoteFunction (InvokeServer και OnServerInvoke) μόνο όταν ο client χρειάζεται απάντηση. Αποφύγετε το InvokeClient: ένας client που βγάζει σφάλμα, που φεύγει ή που δεν επιστρέφει ποτέ τιμή χαλάει την κλήση στον server.
  • Μην εμπιστεύεστε ποτέ ό,τι στέλνει ο client. Στον server ελέγχετε τον τύπο, το εύρος και την κυριότητα κάθε ορίσματος, την απόσταση από τον παίκτη και πόσο συχνά καλεί το remote.
  • Συναρτήσεις, metatables και αντικείμενα που δεν βλέπει η άλλη πλευρά δεν επιβιώνουν από τη μεταφορά. Το UnreliableRemoteEvent μπορεί να χάσει μηνύματα ή να αλλάξει τη σειρά τους και απορρίπτει κάθε δεδομένο πάνω από 1000 bytes.
Σε αυτή τη σελίδα
  1. Γιατί remotes
  2. Ρύθμιση των remotes
  3. 1. Client προς server
  4. 2. Server προς client
  5. 3. Server προς όλους
  6. RemoteFunction
  7. Λίστα ελέγχων
  8. Τι δεν στέλνεται
  9. Επιστρέφει nil;
  10. UnreliableRemoteEvent
  11. Σειρά και όρια
  12. Τι να διαλέξετε
  13. Common errors
  14. Με το RoCode
  15. Συχνές ερωτήσεις
  16. Πηγές και περαιτέρω ανάγνωση

Γιατί χρειάζονται τα RemoteEvent

ΕικονογράφησηΚάθε κλικ ζητά από τον server να βάψει ένα part, γι' αυτό το νέο χρώμα φαίνεται στις οθόνες και των δύο παικτών.

Κάθε παιχνίδι Roblox λειτουργεί ως ένας server συν έναν client για κάθε παίκτη. Ο server εδώ είναι το κύριο: ένα νέο αντικείμενο ή μια αλλαγή ιδιότητας φτάνει σε όλους τους παίκτες μόνο όταν την κάνει ο server. Μια αλλαγή που γίνεται σε LocalScript μένει σε μία συσκευή, με λίγες εξαιρέσεις όπως ο ίδιος ο χαρακτήρας του παίκτη, την κίνηση του οποίου ελέγχει ο client του. Γι' αυτό, όταν ένα κλικ ή ένα πλήκτρο πρέπει να αλλάξει τον κοινό κόσμο, ο client πρέπει να ζητήσει από τον server, και όταν ο server θέλει να αντιδράσει η οθόνη ενός παίκτη, πρέπει να το πει στον client. Αν ο διαχωρισμός σε Script και LocalScript είναι καινούργιος για εσάς, διαβάστε πρώτα το Script vs LocalScript vs ModuleScript (στα αγγλικά). Αν είναι καινούργιο το ίδιο το scripting, ξεκινήστε από το πώς γράφονται scripts στο Roblox Studio.

Για να περάσετε αυτό το όριο, το Roblox δίνει τρία αντικείμενα:

  • RemoteEvent: μήνυμα προς μία κατεύθυνση. Ο αποστολέας συνεχίζει αμέσως τη δουλειά του.
  • RemoteFunction: αίτημα που περιμένει απάντηση. Ο κώδικας που το κάλεσε μένει σε παύση μέχρι η άλλη πλευρά να επιστρέψει τιμή.
  • UnreliableRemoteEvent: μήνυμα προς μία κατεύθυνση που μπορεί να χαθεί ή να φτάσει εκτός σειράς, αλλά φορτώνει λιγότερο το δίκτυο. Ταιριάζει σε δεδομένα που αλλάζουν συνεχώς.
Ποια κλήση πυροδοτεί ποιο event
ΚατεύθυνσηΟ αποστολέας καλείΟ παραλήπτης συνδέεται στοΟ παραλήπτης λαμβάνει
Από τον client στον serverremote:FireServer(...) σε LocalScriptremote.OnServerEvent σε ScriptΤον Player που έστειλε το μήνυμα, μετά τα δικά σας ορίσματα
Από τον server σε έναν clientremote:FireClient(player, ...) σε Scriptremote.OnClientEvent σε LocalScriptΜόνο τα δικά σας ορίσματα
Από τον server σε όλους τους clientsremote:FireAllClients(...) σε Scriptremote.OnClientEvent σε LocalScriptΜόνο τα δικά σας ορίσματα
Ο client ρωτά, ο server απαντάremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Τον Player, μετά τα δικά σας ορίσματα. Αυτός που κάλεσε παίρνει ό,τι επέστρεψε η συνάρτηση

Οι clients δεν μπορούν να στέλνουν μηνύματα απευθείας ο ένας στον άλλον. Για να περάσετε κάτι από έναν παίκτη στους υπόλοιπους, στείλτε το στον server, ελέγξτε το εκεί, και αφήστε τον server να το προωθήσει με FireClient ή FireAllClients. Σύμφωνα με τις συστάσεις ασφαλείας της Roblox, ο server εδώ λειτουργεί ως φύλακας και όχι ως απλός αναμεταδότης.

Πού να κρατάτε τα remotes

Ένα remote πρέπει να βρίσκεται κάπου όπου το βλέπουν και ο server και οι clients. Η συνηθισμένη θέση είναι το ReplicatedStorage· η τεκμηρίωση της Roblox σημειώνει ότι σε κάποιες περιπτώσεις κάνουν και το Workspace ή ένα Tool. Τα ServerStorage και ServerScriptService είναι προσβάσιμα μόνο από τον server, οπότε ένα LocalScript που περιμένει remote από εκεί θα περιμένει για πάντα.

  1. Στο Explorer περάστε τον κέρσορα πάνω από το ReplicatedStorage, πατήστε το κουμπί + και προσθέστε ένα Folder. Ονομάστε τον φάκελο Remotes.
  2. Περάστε τον κέρσορα πάνω από το Remotes, πατήστε + και προσθέστε ένα RemoteEvent. Μετονομάστε το ώστε το όνομα να περιγράφει τον σκοπό του, για παράδειγμα PaintRequest.
  3. Επαναλάβετε για κάθε remote. Αυτός ο οδηγός χρησιμοποιεί δύο RemoteEvent (PaintRequest και Notify) και ένα RemoteFunction (RedeemCode).
Explorer: όλα όσα προσθέτει αυτός ο οδηγός, ενότητα προς ενότητα
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

Τα scripts αυτού του οδηγού βρίσκουν τα remotes με WaitForChild. Επιστρέφει αμέσως αν το remote υπάρχει ήδη, και περιμένει αν δεν υπάρχει ακόμα, για παράδειγμα όταν ένα script του server δημιουργεί τα remotes κατά τη διάρκεια του παιχνιδιού. Φτιάχνετε ξεχωριστό remote για κάθε είδος αιτήματος: έτσι κάθε handler του server ελέγχει ένα μόνο σχήμα ορισμάτων, και είναι πολύ πιο εύκολο να το κάνει σωστά απ' ό,τι με ένα remote για όλες τις περιπτώσεις.

Μοτίβο 1: από τον client στον server, με έλεγχο στον server

Η πιο συχνή περίπτωση: ο παίκτης κάνει κάτι στην οθόνη του και ο server αποφασίζει τι θα συμβεί. Εδώ ο παίκτης πατά Q για να διαλέξει ένα από τέσσερα χρώματα, και κάνει κλικ ή πατά σε ένα part για να το βάψει. Το νέο χρώμα το βλέπουν όλοι, επειδή βάφει ο server.

Ο client στέλνει δύο πράγματα: ποιο part και τον αριθμό του χρώματος. Το ίδιο το χρώμα δεν το στέλνει ποτέ, και σε άλλα παιχνίδια με τον ίδιο τρόπο δεν πρέπει να στέλνει τιμή, ανταμοιβή ή ποσό ζημιάς. Ένας τροποποιημένος client μπορεί να στείλει οτιδήποτε, οπότε τα πραγματικά δεδομένα (εδώ η παλέτα) τα κρατά ο server, και τα ορίσματα τα αντιμετωπίζει ως αίτημα που πρέπει να ελεγχθεί.

  1. Στο Workspace προσθέστε ένα Folder με όνομα Paintable και βάλτε μέσα μερικά Anchored Parts.
  2. Ελέγξτε ότι στο ReplicatedStorage.Remotes υπάρχει RemoteEvent με όνομα PaintRequest.
  3. Προσθέστε ένα Script με όνομα PaintServer στο ServerScriptService και ένα LocalScript με όνομα PaintClient στο StarterPlayer, StarterPlayerScripts, με τον παρακάτω κώδικα.
Script στο ServerScriptService με όνομα 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")

-- Τα χρώματα ανήκουν στον server. Ο client στέλνει μόνο έναν αριθμό που διαλέγει ένα από αυτά.
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 ανάμεσα στον χαρακτήρα και το part
local COOLDOWN_SECONDS = 0.25

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

-- Η πρώτη παράμετρος είναι πάντα ο παίκτης που κάλεσε το remote. Τη βάζει το Roblox,
-- οπότε μπορείτε να την εμπιστευτείτε. Ό,τι ακολουθεί ήρθε από τον client, και σε αυτό δεν μπορείτε.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Τύπος: πραγματικό part, όχι πίνακας που προσποιείται ότι είναι
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Εύρος: ακέραιος από 1 ως 4. Το NaN και το άπειρο κόβονται κι αυτά εδώ.
	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. Επιτρεπτός στόχος: μόνο parts στον φάκελο Paintable, τίποτα άλλο στο παιχνίδι
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Απόσταση: ο χαρακτήρας του παίκτη πρέπει να είναι κοντά στο part
	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. Όριο συχνότητας: ένα βάψιμο ανά παίκτη κάθε τέταρτο του δευτερολέπτου
	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)

Κάθε έλεγχος που αποτυγχάνει απλώς κάνει return. Δεν υπάρχει λόγος να εξηγήσετε σε έναν client που κλέβει γιατί απορρίφθηκε.

LocalScript στο StarterPlayerScripts με όνομα 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 -- τα πραγματικά χρώματα τα κρατά ο server
local selectedColour = 1

-- Η ακτίνα μπορεί να χτυπήσει μόνο parts μέσα στον φάκελο Paintable
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- το πλήκτρο ή το κλικ πήγε στη συνομιλία ή σε κουμπί
	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
			-- Ζητάμε, δεν διατάζουμε: αν θα βάψει ή όχι, το αποφασίζει ο server
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

Το gameProcessed είναι true όταν η μηχανή έχει ήδη χειριστεί αυτή την είσοδο, συνήθως στο UI: κλικ σε κουμπί ή πλήκτρα που πληκτρολογήθηκαν σε πεδίο κειμένου όπως η γραμμή της συνομιλίας. Χάρη σε αυτόν τον έλεγχο, ένα Q που γράφεται σε μήνυμα δεν αλλάζει το χρώμα.

Μοτίβο 2: από τον server σε έναν client

Ο server στέλνει μήνυμα σε έναν παίκτη με FireClient. Το πρώτο όρισμα είναι ο Player στον οποίο απευθύνεται, και ο handler στον client λαμβάνει μόνο τα ορίσματα μετά από αυτό. Χρησιμοποιήστε το για ό,τι είναι προσωπικό: μια ειδοποίηση, ένα παράθυρο ανταμοιβής, έναν ήχο που πρέπει να ακούσει μόνο αυτός ο παίκτης. Ο οδηγός για cutscenes είναι ένα μεγαλύτερο αναλυμένο παράδειγμα: ο server αποφασίζει πότε ο παίκτης θα δει το cutscene και στέλνει τα πλάνα του σε αυτόν τον έναν παίκτη με FireClient, ενώ την κάμερα τη μετακινεί η συσκευή του.

Αυτό το ζευγάρι scripts δείχνει ένα μήνυμα καλωσορίσματος όταν μπαίνει ο παίκτης. Το LocalScript φτιάχνει μόνο του ένα μικρό banner, οπότε δεν χρειάζεται να στήσετε GUI.

Script στο ServerScriptService με όνομα WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local function welcome(player: Player)
	-- Το πρώτο όρισμα διαλέγει ποιος client θα πάρει το μήνυμα. Κανείς άλλος δεν θα το δει.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- Στο Studio μπορείτε να μπείτε πριν συνδεθεί αυτό το script, οπότε καλωσορίζουμε όσους είναι ήδη εδώ
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript στο StarterPlayerScripts με όνομα NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Ένα μικρό banner στο πάνω μέρος της οθόνης, φτιαγμένο σε κώδικα
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

-- Εδώ δεν υπάρχει παράμετρος player: ο server έχει ήδη διαλέξει ποιος θα πάρει το μήνυμα
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 -- κρύβουμε, αν δεν το αντικατέστησε νεότερο μήνυμα
			label.Visible = false
		end
	end)
end)

Ο server στέλνει το μήνυμα στο PlayerAdded, και αυτό μπορεί να γίνει πριν αυτό το LocalScript συνδέσει τον handler του. Δεν πειράζει: το Roblox βάζει σε ουρά τα μηνύματα RemoteEvent που φτάνουν πριν υπάρξει handler και τα παραδίδει με τη σειρά μόλις συνδεθεί.

Ο client δεν χρειάζεται να προστατεύεται από τον server: το OnClientEvent μπορεί να το πυροδοτήσει μόνο κώδικας του server. Η σημείωση message: string υπάρχει για τον έλεγχο τύπων· δεν είναι έλεγχος κατά την εκτέλεση.

Μοτίβο 3: από τον server σε όλους τους clients

Το FireAllClients στέλνει το ίδιο μήνυμα σε κάθε συνδεδεμένο παίκτη. Δεν έχει όρισμα Player, και κάθε client λαμβάνει το μήνυμα στο ίδιο OnClientEvent όπως πριν, οπότε το script NotifyClient του μοτίβου 2 ήδη το εμφανίζει.

Αυτό το Script ανακοινώνει σε όλους πότε ένας παίκτης αγγίζει για πρώτη φορά τη γραμμή τερματισμού. Προσθέστε στο Workspace ένα Anchored Part με όνομα FinishLine, μετά προσθέστε το Script στο ServerScriptService.

Script στο ServerScriptService με όνομα 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 -- δεν είναι παίκτης ή έχει ήδη ανακοινωθεί
	end
	finished[player] = true

	-- Κάθε συνδεδεμένος client τρέχει τον δικό του handler OnClientEvent με αυτό το κείμενο
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

Ένας exploiter μπορεί να πυροδοτήσει το Touched για τον χαρακτήρα του από οποιαδήποτε απόσταση, αλλά για μια ανακοίνωση που εμφανίζεται μία φορά ανά παίκτη αυτό είναι αβλαβές. Αν αργότερα δίνετε ανταμοιβή για τον τερματισμό, προσθέστε ελέγχους στον server πριν τη δώσετε, για παράδειγμα έναν ελάχιστο χρόνο από την αρχή του γύρου.

Το FireAllClients φτάνει μόνο στους παίκτες που είναι συνδεδεμένοι εκείνη τη στιγμή. Όποιος μπει ένα δευτερόλεπτο αργότερα δεν θα δει το μήνυμα. Αυτό ταιριάζει σε στιγμιαία γεγονότα, όπως μια ανακοίνωση, ένα εφέ έκρηξης ή ένας ήχος, αλλά όχι σε κατάσταση όπως ο χρονομετρητής του γύρου ή η τρέχουσα φάση του παιχνιδιού. Για κατάσταση, ορίστε στον server ένα attribute, για παράδειγμα ReplicatedStorage:SetAttribute("TimeLeft", 30), και διαβάστε το στον client με GetAttribute και GetAttributeChangedSignal("TimeLeft"). Τα attributes αναπαράγονται σε κάθε client, μαζί με τους παίκτες που μπήκαν αργότερα.

RemoteFunction: όταν ο client χρειάζεται απάντηση

Το RemoteEvent λειτουργεί με τη λογική «στείλε και ξέχνα». Το RemoteFunction βάζει αυτόν που καλεί να περιμένει: το InvokeServer βάζει σε παύση τον κώδικα που το κάλεσε μέχρι η συνάρτηση OnServerInvoke του server να επιστρέψει τιμή, και μετά δίνει ό,τι επέστρεψε. Χρησιμοποιήστε το όταν ο client δεν μπορεί να συνεχίσει χωρίς απάντηση, για παράδειγμα «ήταν σωστός αυτός ο κωδικός;». Όταν δεν χρειάζεται απάντηση, η Roblox συνιστά RemoteEvent, επειδή δεν περιμένει.

Παράδειγμα: ένα πεδίο όπου οι παίκτες γράφουν κωδικό προσφοράς. Ο server κρατά τους κωδικούς, ελέγχει το κείμενο και επιστρέφει δύο τιμές: αν λειτούργησε και το μήνυμα που πρέπει να εμφανιστεί.

  1. Στο ReplicatedStorage.Remotes προσθέστε ένα RemoteFunction με όνομα RedeemCode.
  2. Στο StarterGui προσθέστε ένα ScreenGui με όνομα CodeGui, και μέσα του ένα TextBox με όνομα CodeBox. Μέγεθος και θέση όπως σας αρέσει.
  3. Προσθέστε το παρακάτω Script στο ServerScriptService και το LocalScript μέσα στο CodeBox.
Script στο ServerScriptService με όνομα RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Οι κωδικοί ζουν στον server, όπου κανένας παίκτης δεν μπορεί να τους διαβάσει
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 } = {}

-- Αναθέτουμε με =. Το OnServerInvoke είναι callback, όχι event στο οποίο κάνετε Connect.
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)

Προσθέτει στο στατιστικό Coins από τον οδηγό για το leaderboard. Οι κωδικοί που χρησιμοποιήθηκαν θυμούνται μόνο μέχρι να φύγει ο παίκτης, οπότε σε αυτή τη μορφή ένας παίκτης μπορεί να ξαναμπεί και να γράψει τον ίδιο κωδικό ξανά. Αν τα νομίσματα αποθηκεύονται, αυτό σημαίνει δωρεάν νομίσματα σε κάθε επανείσοδο: πριν το χρησιμοποιήσετε σε ζωντανό παιχνίδι, κρατήστε τους χρησιμοποιημένους κωδικούς κάθε παίκτη μαζί με τα αποθηκευμένα δεδομένα του στο data store.

LocalScript στο TextBox CodeBox με όνομα 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 βάζει αυτή τη συνάρτηση σε παύση μέχρι το callback του server να επιστρέψει τιμή.
	-- Το pcall δεν αφήνει το LocalScript να σταματήσει αν η κλήση αποτύχει.
	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)

Ένα RemoteFunction έχει ακριβώς ένα callback στον server. Αν δύο scripts ορίζουν OnServerInvoke στο ίδιο RemoteFunction, ισχύει μόνο το τελευταίο.

Γιατί είναι επικίνδυνο το InvokeClient

Το RemoteFunction λειτουργεί και προς την άλλη κατεύθυνση, με InvokeClient στον server και OnClientInvoke στον client. Η τεκμηρίωση της Roblox αναφέρει τρεις σοβαρούς κινδύνους:

  • Αν το callback του client βγάλει σφάλμα, βγάζει σφάλμα και ο server.
  • Αν ο παίκτης φύγει κατά τη διάρκεια της κλήσης, το InvokeClient βγάζει σφάλμα.
  • Αν ο client δεν επιστρέψει ποτέ τιμή, το script του server θα περιμένει για πάντα.

Ένας τροποποιημένος client ελέγχει το callback του, οπότε κάποιος που κλέβει μπορεί να προκαλέσει σκόπιμα την τρίτη περίπτωση και να κρατά αυτό το thread του server όσο θέλει. Για να ενημερώσετε την οθόνη ενός παίκτη, χρησιμοποιήστε FireClient. Αν ο server χρειάζεται πραγματικά πληροφορία από τον client, στείλτε ένα RemoteEvent, αφήστε τον client να απαντήσει με άλλο RemoteEvent, και θεωρήστε στον server την έλλειψη απάντησης κανονική περίπτωση.

Ελέγχετε κάθε όρισμα στον server

Ένας exploiter μπορεί να καλέσει κάθε RemoteEvent ή RemoteFunction όσες φορές θέλει και με όποια ορίσματα θέλει. Το μόνο που δεν μπορεί να πλαστογραφήσει είναι η πρώτη παράμετρος: το Roblox βάζει μόνο του τον Player που έστειλε το μήνυμα. Ό,τι ακολουθεί πρέπει να ελεγχθεί πριν ο server κάνει οτιδήποτε. Το να κρύψετε το remote ή να ελέγχετε σε LocalScript δεν βοηθά, επειδή αυτός που κλέβει ελέγχει τον client του.

Λίστα ελέγχων για τον server
ΈλεγχοςΕρώτηση που κάνει ο serverΠαράδειγμα
ΤύποςΕίναι ο τύπος που περιμένω; Instance, και όχι πίνακας φτιαγμένος ώστε να του μοιάζει;typeof(part) == "Instance" and part:IsA("BasePart")
ΕύροςΟ αριθμός είναι πεπερασμένος και μέσα στα επιτρεπτά όρια; Το κείμενο έχει λογικό μήκος;math.isfinite(n), n >= 1 and n <= 4, #text <= 20
ΚυριότηταΟ παίκτης έχει το αντικείμενο, του φτάνουν τα χρήματα, έχει δικαίωμα να κάνει κάτι με αυτό το αντικείμενο;Το αντικείμενο είναι στο inventory του· το part βρίσκεται μέσα στο Paintable
ΑπόστασηΕίναι ο χαρακτήρας του παίκτη αρκετά κοντά στο αντίγραφο του κόσμου που έχει ο server; Αφήστε ένα μικρό περιθώριο για lag.Όχι πάνω από 30 studs από το part
ΣυχνότηταΣτέλνει αυτός ο παίκτης πολύ συχνά;Cooldown ανά παίκτη ή όριο με συσσώρευση κλήσεων

Το NaN θέλει ξεχωριστή προειδοποίηση. Είναι αριθμός, οπότε το type(x) == "number" περνά, αλλά κάθε σύγκριση μαζί του δίνει false, και ένας έλεγχος όπως x < 0 or x > 100 το αφήνει να περάσει. Το math.isfinite(x) απορρίπτει το NaN και τα δύο άπειρα.

Θυμηθείτε το όριο του ελέγχου απόστασης. Κάθε client ελέγχει τη φυσική του χαρακτήρα του, οπότε ένας exploiter μπορεί πριν την κλήση να μετακινήσει τον χαρακτήρα κοντά στον στόχο. Ο έλεγχος σταματά πάντως την πιο απλή κατάχρηση, όταν από ένα σημείο επηρεάζει κανείς όλο τον χάρτη. Κρατήστε τα parts-στόχους Anchored: η τεκμηρίωση ασφαλείας της Roblox σημειώνει ότι ένας exploiter μπορεί να πάρει network ownership σε μη Anchored parts κοντά του και να τα τραβήξει πιο κοντά, κάτι που παρακάμπτει τον έλεγχο απόστασης.

Εδώ είναι οι ίδιοι έλεγχοι ως ModuleScript που μπορείτε να χρησιμοποιείτε σε κάθε handler remote.

ModuleScript στο ServerScriptService με όνομα RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Πραγματικός αριθμός ανάμεσα σε min και max. Απορρίπτει NaN και άπειρο, που περνούν
-- τον απλό έλεγχο type(x) == "number".
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 και max, για ποσότητες, δείκτες και μετρητές
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

-- Κείμενο με όριο μήκους. Το utf8.len επιστρέφει nil για μη έγκυρο UTF-8, το οποίο
-- απορρίπτουν τα data stores.
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

-- Instance της αναμενόμενης κλάσης μέσα σε container που επιτρέψατε.
-- Ένας πίνακας φτιαγμένος ώστε να μοιάζει με Instance δεν περνά τον έλεγχο typeof.
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 όταν ο χαρακτήρας του παίκτη απέχει το πολύ maxDistance studs από το position
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

-- Όριο συχνότητας ανά παίκτη. Κάθε παίκτης μπορεί να κάνει `burst` κλήσεις αμέσως και
-- παίρνει πίσω `perSecond` κλήσεις κάθε δευτερόλεπτο. Επιστρέφει μια συνάρτηση που καλείται
-- πριν τη δουλειά: απαντά true (επιτρέπεται) ή false (πολύ συχνά).
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. Ο κώδικας από εκεί δεν φτάνει ποτέ στους clients, οπότε κανείς δεν θα διαβάσει τους ελέγχους σας.

Και εδώ είναι ο handler του μοτίβου 1, ξαναγραμμένος με τη βοήθειά του. Αντικαταστήστε το περιεχόμενο του PaintServer:

Script στο ServerScriptService με όνομα PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- Το ":: any" έχει σημασία μόνο για τον αυστηρό έλεγχο τύπων του Luau· κατά την εκτέλεση δεν αλλάζει τίποτα
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, μετά 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)

Το limiter διαγράφει την εγγραφή του παίκτη όταν αυτός φεύγει, οπότε ο πίνακάς του δεν μεγαλώνει σε όλη τη διάρκεια ζωής του server.

Στα όπλα αυτοί οι έλεγχοι μετράνε περισσότερο: μην αφήνετε ποτέ τον client να λέει ποιον χτύπησε. Το remote του οδηγού για το σπαθί δεν έχει καθόλου ορίσματα, και ο server βρίσκει μόνος του τους στόχους. Ο οδηγός για όπλα στέλνει μόνο το σημείο σκόπευσης, το οποίο ο server ελέγχει για τύπο, NaN και απόσταση πριν ρίξει τη δική του ακτίνα.

Τα μενού ακολουθούν τον ίδιο κανόνα: στείλτε την επιλογή, όχι το αποτέλεσμα. Στον οδηγό για διαλόγους NPC ο client στέλνει μόνο τον αριθμό του κουμπιού που πατήθηκε, και ο server κοιτάζει μόνος του τι δίνει αυτή η απάντηση. Το μενού του οδηγού για τηλεμεταφορές στέλνει το όνομα του σημείου, όχι τη θέση, και ο server βρίσκει το σημείο στον δικό του φάκελο και ελέγχει πόσα Wins χρειάζονται για αυτό.

Τι μπορείτε και τι δεν μπορείτε να στείλετε

Μπορείτε να στέλνετε αριθμούς, strings, booleans, τύπους του Roblox όπως Vector3, CFrame, Color3 και στοιχεία Enum, Instances που βλέπουν και οι δύο πλευρές, και πίνακες από όλα αυτά. Κάποιες τιμές αλλάζουν ή χάνονται στη διαδρομή:

Ορίσματα που φτάνουν διαφορετικά απ' ό,τι στάλθηκαν
ΣτέλνετεΤι συμβαίνει
Μια συνάρτησηΗ άλλη πλευρά παίρνει nil
Πίνακα με metatableΤο metatable χάνεται μαζί με ό,τι είχε ο πίνακας μόνο μέσω αυτού
Πίνακα με ανάμεικτα αριθμητικά και string κλειδιάΗ Roblox συμβουλεύει να μην το κάνετε: στείλτε καθαρό array ή καθαρό dictionary
Πίνακα με τιμές nil μέσαΑποφύγετέ το: η Roblox δεν συνιστά nil σε κανέναν δείκτη
Πίνακα με κλειδιά τύπου Instance, userdata ή functionΑυτά τα κλειδιά γίνονται strings
Instance που ο παραλήπτης δεν βλέπει, για παράδειγμα από το ServerStorage ή φτιαγμένο σε LocalScriptΗ άλλη πλευρά παίρνει nil
Οποιονδήποτε πίνακαΟ παραλήπτης παίρνει αντίγραφο, όχι τον ίδιο πίνακα

Καλή συνήθεια: στέλνετε αναγνωριστικά, όχι αντικείμενα ή τιμές. Το όνομα ενός αντικειμένου, τον αριθμό μιας επιλογής, ένα part που ο server μπορεί να βρει και να ελέγξει. Από εκεί και πέρα ο server δουλεύει με τα δικά του δεδομένα.

Γιατί το RemoteFunction επιστρέφει nil

Αν το InvokeServer σας δίνει nil, περάστε από αυτά τα σημεία με τη σειρά:

  1. Διαδρομή χωρίς τιμή επιστροφής. Κάθε έξοδος από το OnServerInvoke πρέπει να επιστρέφει κάτι. Ένα κενό return σε έναν πρώιμο έλεγχο στέλνει πίσω nil.
  2. return μέσα σε εσωτερική συνάρτηση. Ένα return μέσα σε pcall(function() ... end), σε handler :Connect ή σε task.spawn βγαίνει μόνο από αυτή την εσωτερική συνάρτηση. Αποθηκεύστε το αποτέλεσμα, για παράδειγμα local ok, data = pcall(...), και μετά επιστρέψτε το data από το ίδιο το callback.
  3. Τιμή που δεν μπορεί να περάσει το όριο. Μια συνάρτηση ή ένα Instance που ο client δεν βλέπει (για παράδειγμα οτιδήποτε στο ServerStorage) φτάνει ως nil. Με ενεργό το instance streaming, ένα part που ο server μόλις δημιούργησε μπορεί να μην έχει φτάσει ακόμα στον client τη στιγμή που επιστρέφει η συνάρτηση.
  4. Το callback το όρισε άλλο script. Ισχύει μόνο η τελευταία ανάθεση του OnServerInvoke. Ψάξτε το όνομα του remote στα scripts σας.

Αν η κλήση δεν επιστρέφει καθόλου, τότε κανένα script δεν έχει ορίσει ακόμα OnServerInvoke (το Roblox κρατά τις κλήσεις σε ουρά μέχρι να οριστεί) ή το callback κόλλησε, για παράδειγμα σε WaitForChild για κάτι που δεν θα εμφανιστεί ποτέ.

UnreliableRemoteEvent: για συνεχείς, στιγμιαίες ενημερώσεις

Το UnreliableRemoteEvent έχει τις ίδιες μεθόδους και τα ίδια events με το RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent και OnClientEvent. Η διαφορά είναι ότι το Roblox δεν εγγυάται ούτε την παράδοση ούτε τη σειρά. Ένα μήνυμα μπορεί να απορριφθεί χωρίς επανάληψη αποστολής όταν:

  • χάνεται στη διαδρομή ή περιμένει πολύ σε υπερφορτωμένο δίκτυο
  • τα δεδομένα του ξεπερνούν τα 1000 bytes
  • ο client στέλνει πιο συχνά από το όριο (τα επιπλέον απορρίπτονται, δεν αναβάλλονται)
  • τη στιγμή που φτάνει δεν είναι συνδεδεμένος κανένας handler (πετιέται, δεν μπαίνει σε ουρά)

Τα μηνύματα μπορεί να φτάνουν και εκτός σειράς, και η σειρά τους δεν σχετίζεται καθόλου με τα RemoteEvent ή RemoteFunction σας. Χρησιμοποιήστε το όταν μετράει μόνο η πιο πρόσφατη τιμή και η επόμενη ενημέρωση θα έρθει σε κλάσμα του δευτερολέπτου: πού σημαδεύει ο παίκτης, η θέση ενός διακοσμητικού εφέ, μια τιμή που αλλάζει σε κάθε καρέ. Αν η σειρά έχει σημασία, βάζετε σε κάθε μήνυμα αύξοντα αριθμό ή χρονοσφραγίδα και αγνοείτε ό,τι είναι παλαιότερο από το τελευταίο που επεξεργαστήκατε.

Μην το χρησιμοποιείτε ποτέ για κάτι που πρέπει να συμβεί ακριβώς μία φορά, όπως μια αγορά, ζημιά, ανταμοιβή ή έναρξη γύρου. Και ελέγχετε τα ορίσματά του στον server ακριβώς όπως του RemoteEvent.

Σειρά παράδοσης και όρια συχνότητας

Οι εγγυήσεις παράδοσης του Roblox αφορούν μία σύνδεση προς μία κατεύθυνση: από τον server σε έναν client ή από έναν client στον server.

  • Τα RemoteEvent είναι αξιόπιστα και με σειρά. Τα χαμένα μηνύματα ξαναστέλνονται όσο ο παραλήπτης μένει συνδεδεμένος, και τα μηνύματα φτάνουν με τη σειρά που τα στείλατε, ακόμα και μέσα από διαφορετικά RemoteEvent. Αν ο server στείλει σε έναν παίκτη A, μετά B, μετά A, αυτός ο παίκτης λαμβάνει A, B, A.
  • Η σειρά αφορά τη στιγμή που ξεκινούν οι handlers. Αν ένας handler παραχωρεί τον έλεγχο, για παράδειγμα με task.wait ή WaitForChild, το επόμενο μήνυμα μπορεί να αρχίσει να επεξεργάζεται πριν τελειώσει το πρώτο.
  • Τα RemoteFunction και τα RemoteEvent δεν έχουν σειρά μεταξύ τους. Αν ο κώδικάς σας εξαρτάται από αυστηρή σειρά, στείλτε τα σχετικά μηνύματα μέσω ενός τύπου remote ή προσθέστε δικό σας αύξοντα αριθμό.
  • Οι αλλαγές ιδιοτήτων και attributes δεν έχουν σειρά σε σχέση με τα remotes. Αν ο server αλλάξει μια ιδιότητα και μετά καλέσει ένα remote, ο client μπορεί να δει πρώτα οποιοδήποτε από τα δύο. Ακούστε την ίδια την αλλαγή, για παράδειγμα με GetPropertyChangedSignal, αντί να υποθέτετε ότι έχει ήδη φτάσει.
  • Δεν υπάρχει ακόμα handler. Τα μηνύματα RemoteEvent περιμένουν σε ουρά μέχρι να συνδεθεί handler. Η ουρά έχει όρια: όταν γεμίσει, τα επόμενα μηνύματα απορρίπτονται, και στο Output εμφανίζεται το σφάλμα Remote event invocation discarded.
  • Ένας παίκτης που φεύγει χάνει όλα τα μηνύματα που δεν πρόλαβαν να τον φτάσουν.

Όριο συχνότητας. Τα μηνύματα RemoteEvent και UnreliableRemoteEvent από τον client στον server περιορίζονται σε περίπου 500 αιτήματα το δευτερόλεπτο ανά client, σύμφωνα με την τεκμηρίωση στις 30 Σεπτεμβρίου 2026. Το όριο είναι κοινό για όλα τα remotes του ίδιου τύπου, οπότε αν χωρίσετε ένα φορτωμένο remote σε δέκα, δεν το ανεβάζετε. Πάνω από το όριο, τα μηνύματα RemoteEvent επεξεργάζονται αργότερα και κρατούν τη σειρά τους, ενώ τα μηνύματα UnreliableRemoteEvent απορρίπτονται. Το όριο της μηχανής δεν εμποδίζει καθόλου έναν παίκτη να καλεί το remote σας 50 φορές το δευτερόλεπτο, οπότε κάθε handler που αλλάζει κάτι χρειάζεται πάλι το δικό του όριο ανά παίκτη.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent ή attribute;

Πώς να διαλέξετε τρόπο επικοινωνίας client και server
ΧρησιμοποιήστεΓια τιΠαράδειγμαΤι να προσέξετε
RemoteEventΜηνύματα προς μία κατεύθυνση που πρέπει να φτάσουν, και με τη σειράClient: «βάψε αυτό το part». Server: «δείξε αυτή την ειδοποίηση»Ελέγχετε κάθε όρισμα στον server
RemoteFunction με InvokeServerΟ client χρειάζεται απάντηση πριν μπορέσει να συνεχίσειΕισαγωγή κωδικού προσφοράς, επιβεβαίωση αγοράςΑυτός που καλεί περιμένει· κάθε διαδρομή πρέπει να επιστρέφει τιμή
RemoteFunction με InvokeClientΣχεδόν ποτέΧρησιμοποιήστε αντί γι' αυτό FireClientΈνας client που βγάζει σφάλμα, φεύγει ή δεν απαντά χαλάει ή κολλάει την κλήση στον server
UnreliableRemoteEventΣυχνές ενημερώσεις όπου μετράει μόνο η τελευταίαΚατεύθυνση σκόπευσης, διακοσμητικά εφέΤα μηνύματα χάνονται ή αλλάζουν σειρά· όριο δεδομένων 1000 bytes
Attribute ή value-αντικείμενο που ορίζει ο serverΚοινή κατάσταση που πρέπει να φαίνεται πάντα, και σε παίκτες που μπήκαν αργότεραΧρονομετρητής γύρου, φάση παιχνιδιού, αν η πόρτα είναι ανοιχτήΣε όλους φτάνουν μόνο οι αλλαγές του server· οι clients ακούνε με GetAttributeChangedSignal ή Changed
BindableEventΕπικοινωνία scripts στην ίδια πλευράΈνα script του server λέει σε ένα άλλο ότι ο γύρος τελείωσεΔεν περνά ανάμεσα σε server και client

Για ένα πλήρες παράδειγμα του πώς δουλεύουν μαζί RemoteFunction και έλεγχοι εκεί όπου οι παίκτες πληρώνουν, δείτε τον οδηγό πώς να φτιάξεις GUI καταστήματος. Όσο για τη γραμμή με τα attributes, το script του server στον οδηγό για πόρτες ορίζει το attribute Open σε κάθε πόρτα σε κάθε κίνησή της, ώστε να μπορεί να αντιδρά σε αυτό οποιοδήποτε LocalScript.

Συνηθισμένα λάθη και λύσεις

Τα περισσότερα προβλήματα με remotes φαίνονται στο παράθυρο Output (ανοίξτε το από το μενού Window ή από την καρτέλα Script). Κοιτάξτε πρώτα εκεί, μετά βρείτε το σύμπτωμά σας παρακάτω. Ο οδηγός για σφάλματα scripts εξηγεί αναλυτικότερα τα γενικά μηνύματα σφάλματος.

Infinite yield possible στο WaitForChild για ένα remote

Το script περιμένει ένα remote που δεν θα εμφανιστεί ποτέ. Ελέγξτε ότι το όνομα και τα κεφαλαία γράμματα ταιριάζουν ακριβώς και ότι το remote βρίσκεται στο ReplicatedStorage, όχι στο ServerStorage ή στο ServerScriptService, που οι clients δεν βλέπουν.

Ο server λαμβάνει λάθος τιμές, μετατοπισμένες κατά μία

Το LocalScript πέρασε τον ίδιο τον παίκτη, όπως στο remote:FireServer(player, 5). Το Roblox ήδη προσθέτει τον αποστολέα ως πρώτη παράμετρο, οπότε ο server βλέπει (player, player, 5). Καλέστε remote:FireServer(5).

Δεν συμβαίνει τίποτα όταν καλώ το remote

Ελέγξτε ότι κάθε κλήση γίνεται από τη σωστή πλευρά: τα FireServer και InvokeServer δουλεύουν μόνο από κώδικα client, και τα FireClient, FireAllClients και InvokeClient μόνο από Script του server. Ένα LocalScript δεν τρέχει ποτέ στο ServerScriptService, στο ServerStorage ή απευθείας στο Workspace· βάλτε το στο StarterPlayerScripts, στο StarterGui, στο StarterCharacterScripts ή στο StarterPack. Μετά ψάξτε στο Output για σφάλμα μέσα στον handler.

Remote event invocation discarded

Ήρθαν μηνύματα για ένα RemoteEvent που δεν είχε συνδεδεμένο handler, και η ουρά γέμισε. Συνήθως το script με τον handler βγάζει σφάλμα πριν από τη γραμμή με το :Connect, είναι απενεργοποιημένο ή κόλλησε περιμένοντας κάτι που δεν θα φορτώσει ποτέ. Συνδέετε τους handlers κοντά στην αρχή του script.

Σε μένα δουλεύει, αλλά οι άλλοι παίκτες δεν βλέπουν την αλλαγή

Η αλλαγή έγινε στον client, σε LocalScript ή σε handler OnClientEvent. Κάντε την στον handler OnServerEvent του server.

Το InvokeServer δεν επιστρέφει ποτέ

Είτε κανένα script δεν έχει ορίσει OnServerInvoke (το Roblox κρατά τις κλήσεις σε ουρά μέχρι να οριστεί), είτε το callback κόλλησε σε κάτι που παραχωρεί τον έλεγχο, για παράδειγμα σε WaitForChild ή σε αίτημα προς data store. Βάλτε ένα print στην αρχή και στο τέλος του callback για να δείτε πού σταματά.

Φτιάξτε το με το RoCode

Αυτό μπορεί να το στήσει και το RoCode, απευθείας στο place που έχετε ανοιχτό. Το RoCode είναι ένας πράκτορας AI που δουλεύει μέσω ενός plugin για το Roblox Studio, οπότε δημιουργεί τα remotes και τα scripts στο Explorer σας, αντί να σας δίνει κώδικα για επικόλληση.

Εσείς γράφετε

Άφησε τους παίκτες να βάφουν με κλικ τα parts στον φάκελο Paintable. Χρησιμοποίησε RemoteEvent και κράτα τους ελέγχους στον server: μόνο parts από αυτόν τον φάκελο, όχι πάνω από 30 studs απόσταση και όχι πάνω από λίγα βαψίματα το δευτερόλεπτο.

Το RoCode κάνει
  • Συνήθως πρώτα εξετάζει το place με το Search Game και το Search Scripts για έτοιμο φάκελο Remotes ή handler και χρησιμοποιεί τους φακέλους σας, αν υπάρχουν
  • Δημιουργεί το RemoteEvent στο ReplicatedStorage με το Create Instance και γράφει το Script του server και το LocalScript με το Create Script
  • Πριν τελειώσει ελέγχει ότι κάθε script κάνει compile με το Check Script μέσα στο Studio. Αυτό πιάνει σφάλματα compile, όχι λογικά λάθη: δεν ελέγχει τύπους, δεν τρέχει linter και δεν εκτελεί τον κώδικά σας
  • Στέλνει τις αλλαγές σε δέσμες, και κάθε δέσμη είναι ένα σημείο αναίρεσης στο ιστορικό του Studio

Με το plugin 3.9 ή νεότερο το RoCode μπορεί να τρέξει ένα σύντομο playtest και να διαβάσει τα σφάλματα, και με το plugin 3.9.11 ή νεότερο μπορεί να χειριστεί έναν δοκιμαστικό χαρακτήρα, αλλά δεν κάνει κλικ σε parts στο 3D παράθυρο. Πατήστε Play μόνοι σας και προσπαθήστε να σπάσετε τους ελέγχους, για παράδειγμα βάφοντας ένα part από την άλλη άκρη του χάρτη. Αν εμφανιστεί σφάλμα, το Check Output μπορεί να διαβάσει τις γραμμές Server και Client από το τελευταίο σας playtest. Τα περισσότερα συστήματα παιχνιδιού επικοινωνούν μέσω τέτοιων remotes, οπότε θα τα ξανασυναντήσετε όταν φτιάχνετε ένα παιχνίδι σύστημα προς σύστημα με το RoCode. Πώς συνδέεται το RoCode με το Studio.

Συχνές ερωτήσεις

Τι σημαίνει securing the client-server boundary στο Roblox;

Έτσι λέγεται η σελίδα τεκμηρίωσης της Roblox για την ασφάλεια των remotes, και η ιδέα είναι απλή: ό,τι στέλνει ο client μέσω RemoteEvent ή RemoteFunction μπορεί να προέρχεται από exploiter, οπότε ο server το ελέγχει πριν κάνει οτιδήποτε. Ελέγχετε τον τύπο κάθε ορίσματος, κρατάτε τους αριθμούς σε λογικά όρια, ελέγχετε ότι ο παίκτης έχει δικαίωμα να το κάνει αυτή τη στιγμή, και περιορίζετε πόσο συχνά μπορεί κάθε παίκτης να καλεί ένα remote. Η λίστα ελέγχων παραπάνω δείχνει τον καθένα σε κώδικα.

Είναι ασφαλές το RemoteFunction;

Το InvokeServer είναι τόσο ασφαλές όσο το callback του server σας: ελέγχετε τα ορίσματά του και περιορίζετε τη συχνότητα, όπως σε κάθε RemoteEvent. Η επικίνδυνη κατεύθυνση είναι το InvokeClient, επειδή ένας client που βγάζει σφάλμα, φεύγει ή δεν επιστρέφει ποτέ τιμή χαλάει ή κολλάει την κλήση στον server.

Μπορούν οι exploiters να δουν και να καλέσουν τα remotes μου;

Ναι. Ό,τι βρίσκεται στο ReplicatedStorage φτάνει σε κάθε client, και ένας τροποποιημένος client μπορεί να καλέσει κάθε remote με όποια ορίσματα θέλει. Η μετονομασία ή η απόκρυψη των remotes δεν τα κάνει ασφαλή· ασφαλή τα κάνει ο έλεγχος κάθε ορίσματος στον server.

Μπορεί ένας client να στείλει RemoteEvent σε άλλον client;

Απευθείας όχι. Στείλτε το στον server, ελέγξτε το εκεί, μετά χρησιμοποιήστε FireClient ή FireAllClients.

Πόσο συχνά μπορώ να καλώ ένα RemoteEvent;

Η τεκμηρίωση της Roblox αναφέρει όριο περίπου 500 αιτημάτων το δευτερόλεπτο ανά client για μηνύματα RemoteEvent και UnreliableRemoteEvent που στέλνονται στον server, κοινό για όλα τα remotes του ίδιου τύπου. Μείνετε πολύ κάτω από αυτό και δώστε σε κάθε handler το δικό του όριο ανά παίκτη.

Φτάνει το FireAllClients σε παίκτες που μπήκαν αργότερα;

Όχι. Φτάνει στους παίκτες που είναι συνδεδεμένοι εκείνη τη στιγμή. Για κατάσταση που χρειάζονται όσοι έρχονται αργότερα, ορίστε στον server ένα attribute ή ένα value-αντικείμενο.

Ποια η διαφορά ανάμεσα σε RemoteEvent και BindableEvent;

Το RemoteEvent περνά ανάμεσα σε server και client. Το BindableEvent συνδέει scripts στην ίδια πλευρά, για παράδειγμα δύο scripts του server.

Πηγές και περαιτέρω ανάγνωση

Πώς ελέγχθηκε ο κώδικας: κάθε script σε αυτή τη σελίδα περνά αυστηρό έλεγχο τύπων Luau με τους ορισμούς του Roblox API (luau-lsp, 20 Νοεμβρίου 2026). Ο έλεγχος τύπων πιάνει λάθη σε ονόματα API και λάθος τύπους, όχι όμως λάθη στη λογική του παιχνιδιού, γι' αυτό δοκιμάστε τα πάντα στο Studio πριν τη δημοσίευση.

Δοκιμάστε το RoCode στο παιχνίδι σας.

Δωρεάν credits κάθε μέρα, χωρίς κάρτα. Εγκαταστήστε το plugin, περιγράψτε μια λειτουργία και δείτε τι εμφανίζεται στο Studio.