#Client and server

A Studz game runs on a server and on every player's client. Server scripts are trusted; clients are not. This page covers what a LocalScript can do, and how the two sides talk through remotes.

#LocalScripts

A LocalScript runs on one player's computer. It sees the replicated world, Players.LocalPlayer, workspace.CurrentCamera, input and its own GUI.

local Players = game:Service("Players")
local UIS = game:Service("UserInputService")
local player = Players.LocalPlayer

local label = Instance.new("TextLabel")            -- drawn for this player only
label.Text = "Hello, " .. player.Name
label.Position = UDim2.new(0.5, 0, 0.1, 0)

UIS.InputBegan:On(function(input, gameProcessed)
    if gameProcessed then return end               -- typing in chat, menu open
    if input.KeyCode == Enum.KeyCode.E then
        print("E pressed")
    end
end)

LocalScripts only start with the place. Creating one with Instance.new at runtime does nothing.

#What a client can and cannot do

A part changed locally is overwritten when the server next changes it.

#Input

UserInputService (game:Service("UserInputService")):

Enums for input: Enum.KeyCode, Enum.UserInputType, Enum.UserInputState and Enum.NormalId.

#The mouse

player:GetMouse() returns a mouse object.

#The camera

workspace.CurrentCamera is read-only for now.

#Remotes

A remote is an object that carries a message between server and client. Put a RemoteEvent or RemoteFunction in the Workspace or in ReplicatedStorage. Insert it from the Script ribbon or the Explorer in Polycarbonate. Both sides find it by name.

The containers ReplicatedStorage, ServerStorage, ReplicatedFirst, ServerScriptService and StarterPlayer all exist. Objects placed anywhere are also found through them.

#RemoteEvent: one-way messages

#RemoteFunction: ask and wait for an answer

#BindableEvent

For signalling between scripts on the same side. :Fire(...) sends, .Event:On(fn) receives.

#A complete example

-- Server Script
local remote = game.ReplicatedStorage:GetChild("Buy")
remote:Listen({ "string", "integer" }, function(player, item, count)
    remote:ToPlayer(player, "bought", item)                    -- or :ToAll(...)
end)
game.ReplicatedStorage.GetCoins.OnServerCall = function(player)
    return coinsOf[player.Name]
end

-- LocalScript
remote:ToServer("sword", 1)
remote.FromServer:On(function(what, item) print(what, item) end)
local coins = game.ReplicatedStorage.GetCoins:CallServer()     -- waits up to 10 s for the reply

#What can be sent

Arguments can be nil, booleans, numbers, strings, Vector3, Color3, players, parts, and tables of those. Functions and other objects are refused with an error.

#Validating with Listen

Never trust a client. remote:Listen(schema, handler) checks every argument before your function sees it. schema lists the expected types in order:

Add ? for an optional argument: "Vector3?". A call with the wrong type, a NaN, an overlong string or too many arguments is dropped with a warning and never reaches your handler.

Listen checks types, not meaning. You still have to check that the item exists, the count is sensible and the player may do this:

local prices = { sword = 10, bow = 25 }
buy:Listen({ "string", "integer" }, function(player, item, count)
    local price = prices[item]
    if not price or count < 1 or count > 10 then return end
    -- charge the player, give the item ...
end)