Part 2 Remote Events & Functions

In this section, we’ll be talking about Remote Events & Remote Functions + how to secure them as much as possible.

So first, what are they and why do we need them?
To those of you who didn’t know, back then - before Roblox changed and updated their filterenabled system & security, exploiters could basically do any type of exploit they wanted - it was a disaster, tons of exploits that ruined some good & popular games. And that’s when Roblox have decied to add remote event and functions. This wouldn’t completely stop exploiters tho, but it SIGNIFICANTALLY changed and fixed tons of issues, including patching alot of exploits that no longer work.

As mentioned above, the idea of using RemoteEvents and RemoteFunctions is to help us handle our game as correctly as possible, and to protect our game from being completely ruined. From the moment they were added, we now can use them to prevent exploiters from doing some crazy and weird exploits. Le’ts begin!

A remote event allows us to : one-way communicate across the client-server boundary. You can use it to send requests across the boundary without yielding for a response.[ Meaning: You could use these to handle things on the server / client when needed.

When can I use remote events ?
Remote events are good to use in these cases:

Using this to fire an event from a certain client[player] to the server, so that everyone could see those changes. Let’s have an example:

As you can see here, on the server side, we’re using FireAllClients() function, which would fire/ notify every client[player] in the game, about the given event/message provided / made on the client. Note: the message could’ve been made on the server and sent as the second argument within the FireAllClients().
On the client side, we use game:GetService("StarterGui"):SetCore() to create a message on chat, so that everyone in-game can see that.

This can’t be directly done, so it has to be through the server. Here is how:
You can use FireServer() to share the server with the changes, then on the server, use FireClient() or FireAllClients() to fire the client[s] ,and then use OnClientEvent() on the client to do the stuff.

A remote function , unlike remote events, allow us to two-way communicate across the client-server boundary. You can use it to send requests across the boundary and yield for a response. Here it what it means:

Player1: Invokes the server [ using InvokeServer()], then, on the server ,he returns something [ most commonly is booleans], and then - on the client, he can use that result after he assigned the InvokeServer() call as a variable, like this -local call = remote:InvokeServer(). (This is very useful when we want to make a code redeeming system, for example, or even a trade system).

When can I use remote functions?
Remote functions are good to use in these cases:

Not recommended, do not try it unless you’ve a strong sanity checks that would prevent exploiters from ruining and messing up with it. These are the risks you could have with it:

1.If the client throws an error, the server throws the error too.
2.If the client disconnects while it’s being invoked, then throws an error.
3.If the client doesn’t return a value, the server yields forever.

In this section, we’ll be talking about the Player and its ‘visual’ appearance - the Character.
We’ll talk about how they’re different, and what each has and offers, that the second - does not.

The Player is an object/instance, where you can view most of the main things/properties your player/other players have in-game[ and some can actually give info from out of the game]. To be a bit more accurate, every Player object represents the Client when they’re connected to the game.

Like every other object, the Player object has properties aswell, let’s review some of them:

This property is an ObjectValue, and it should represent the actual model of the player - the character [ which we can visually see in-games].

Obviously, this property is a String, and it should represent the DisplayName of the player.

This property is a Number , and it automatically updates the Age [in days] of the player.
NOTICE: this property is read only, meaning - you can’t modify or change that property.

This property belongs to the Team class, and this allows us to know/edit and change the player’s team.The Team value itself, is an ObjectValue. And it’s supposed to represent the player’s team or nil [if the team doesnt exist/destroyed].

In here, we’ll be talking about some cool and useful events the Player object has.

This event should fire every time the player’s character spawns or respawns.

This event would fire each time the player is chatting through Roblox built-in chat.

In here, we’ll be talking about some useful methods you might need to know and use.

This method would remove all accessories and objects from the player’s character.[if they are decals, accessories and clothes].

This method would kick the player from your game and show him the given message [if given], if not,t then the default Roblox message.

The Character is a Model object, which should represent the player’s character [ or any player’s character], and can also be used for making NPC’s. Every character essentially contains:
Humanoid ,HumanoidRootPart and a Head part. About other limbs - depending on what rig you’re using [R6 or R15].The character is the entity of yourself and other players in games , which allows you to do actions [ run, walk,sit, jump ,dance] and more things that can be viewed from the character prespective.

Like every other object/instance, the Character object has properties aswell, let’s review some of them.

This property [ boolean ] would determine if the object is included in the game and can be seen when published and it also impacts to clone objects. If set to false, the object won’t be cloned. If set to true, the object will be cloned when using the Clone() method.

This is an ObjectValue, which refers to the PrimaryPart of your model. You should know that -
The primary part acts like the physical reference for the pivot of the model, which basically means -
The pivot will move in sync with the primary part. If the primary part is not set, the pivot will stay at the same position in world space even if parts within the model are no longer there.
It is also important to mention that when setting a primary part, that primary part has to be a descendant of that model, or else - setting that primary part will change it to nil automatically.

In here, we’ll be talking about some useful events to use on our character.

This event would run when the parent or any of its ancestors is changed. It includes 2 parameters: child and parent. Where:

child is the object whose parent was changed.
parent is the new parent of that child[object].

In this section, we’ll be learning about some cool and useful methods to use on our character.

This method will break any connection between parts in your character. Using this on your character, will kill you [ by killing your humanoid].

This method will move the character/any model’s primary part to the provided position.Make sure your model always has a PrimaryPart. Because if your model doesnt have one, this would select the root part of that model as the primary part. And, since the root part is not deterministic, it is recommended to always set a primary part.

In this section, we’ll be talking about tools, backpack ,startergear, and how to use and how they work.

By definition, tools on Roblox are objects which the Character[ if he has a humanoid within], can equip , unequip and activate it. Notice this pattern:
Tool is in Backpack → Player Equips it – > Tools is now in his Character.
When you place tools in StarterPack, this would put all the given tools under the player’s Backpack folder. [From where he can equip his tools].

You notice that when you die, you lose your tools. How can you prevent this?
Simply make sure the tools are also in StarterGear, this would give you those items each time you die/reset.

On desktops,pressing a number key (1, 2, 3…) will equip the tool whose index is at that number key.
[Meaning, pressing 1 should give you the first tool, etc.]
Let’s review a quick example:

The tool in the above example will create an explosion at the position of the tool owner.
Let’s now move onto Properties, Events and Methods.

In here, we’ll be talking about some useful properties you might need when working with tools.

This property will determine if you can drop your tool [by pressing Backspace] or not.

This property will determine if you can actually use the tool or not.[ Say you wanted to remain that tool in the player’s backpack, but only preventing him from using it].
When set to true, the player can use the tool. When set to false, the tool is disabled and the player cannot use it. This would also prevent any Activation / Deactivation events from happening, since you aren’t able to use the tool if set to false.

This property determines if your tool can work without the need of a handle.
[Meaning that if your tool doesnt have a handle, and that property is set to false, then you could still activate your tool and do stuff].

In here, we’ll be talking about some useful events on tools.

This event runs whenever the player clicks while equipping a tool.
[Do not get confused with the method Activate().]

This event runs whenever the player equips a tool.

In this section, we’ll be learning about some useful methods to do with tools.

This method simply clears every child / descendant of the given object.
Notice that if you’re wishing to not clear completely all children, you could use a for loop + an if statement to check the class of the children , etc.

In this category, we’ll be trying to understand the ideas behind gamepasses and devproducts, and what they do.Before we dive into that, let’s first explain what service they stand behind.
As you might know, each service in Roblox Studio has different types of tasks to do/get.
And obviously, not all services are shown in the Explorer.

In this part, we’ll be using the Marketplace Service.
MarketplaceService allows us to configure and work with in-game transactions, use its methods to fetch information about developer products and gamepasses, and more assets.

It has many many events, as well as methods. We’ll be talking about some prominent ones.

Here,we’ll be talking about some very useful events to work with MarketplaceService.

This event would run whenever the purchase dialog of a game pass is closed.Meaning whenever the player presses either ‘OK’ or ‘Cancel’.

It contains 3 parameters:

player[instance]: the player object whom got the prompt.
gamePassId[number]: the id of our gamepass.
wasPurchased[boolean]: checks if it was purchased or not.

Notice that we got false here, because I already own this gamepass.

Fires whenever the premium purchase modal closes[ meaning ‘Cancel’ or ‘OK’ buttons].

In this section, we’ll be learning about some useful methods.

This method prompts the given player, the given gamePassID.

This method simply prompts the player to buy/get premium from the game.[Only parameter is the player whom this will be shown to].

This method returns pages/lists of all current DevProducts the game has.

This method returns information about an asset,dev product or even a gamepass.
You should provide the assetID + assetType, meaning:

In this section, we’ll be learning about ClickDetectors and ProximityPrompts.

So, before we dive into it. Let’s first understand what they are and what they do.

ClickDetectors:allow us receive pointer input on 3D objects through their MouseClick event, meaning - lets us click on objects with our cursor, and do lots of stuff. They only work if they’re parented to:
BasePart, Model or Folder's. Here is a very simple example:

ProximityPrompts: unlike ClickDetectors, ProximityPrompts are visualized gui that appears each time the player approaches to objects, within a certain range of a distance.
Here is a simple example:

So after that introduction, let’s begin by learning some of its properties and events.

This property allows you to change the icon of your cursor.

This property tells you from what distance you’re able to click and activate that clickdetector.

This event fires everytime a player presses and releases the left mouse button while the cursor is hovering over a model or any basepart with a clickdetector.Also, it’s important for the player’s character to be within the MaxActivationDistance, in order to activate it.

This event runs whenever the player begins to hover his cursor over the ClickDetector's parent.[Can be used in both Script and LocalScript].

So after that introduction, let’s begin by learning some of its properties and events.

This property is where the text you’ll see on your prompt, like this:

This would determine how long the player would have to hold the prompt.

This would help you determine from what distance the player can activate the prompt.

This event runs whenever the player has done clicking/holding the prompt [and finished it].

This event runs whenever the prompt is being held by the player[make sure HoldDuration is > 0].

​

In this section, we’ll be learning about TweenService, what it does and how to use it.

Tweens are used to interpolate the properties of instances. Meaning, to edit,modify and change them in style/animation.Notice! Only the following types can be used in TweenService:

To start using this server and its features, you should use the main function : TweenService:Create(), which takes information about the object and acts accordingly when playing the tween.

NOTES:
1.You can tween multiple properties at the same time.
2.If you’re trying to tween the same properties at the same time, only the last one of those properties would tween.

In this section, we’ll be learning about Camera ; what it is , and what it does.

Camera on Roblox is a special object which lets us define and view the world from a 3D prespective.
Every time a client[player] joins the game, he has his own camera object.
We can’t access others camera through the server,only on the client, and access ours only. To access/find the camera object, we use Workspace.CurrentCamera.

The Camera object has many important proprties, however - only 5 of them are more important than others, and these are:

[Camera.CFrame]: Simply represents the position and rotation of the camera.
[Camera.Focus](CFrame): Simply sets the focus of the camera to the given CFrame, it is the point where the camera is looking.
[Camera.CameraType]: Determines how will the camera update every frame.
[Camera.CameraSubject]: Determines what object should the camera follow.
[Camera.FieldOfView]: Determines the observable world through the camera field of view.
The bigger the number, the further the field of view is.

In this section, we’ll be learning how to apply animations onto tools/player’s character.
When we talk about Animation here, we talk about loading custom/built in movements/actions for our tools/humanoid actions.When you’re testing in studio, you can view under your humanoid, there is an object named Animator. The Animator is the main object that is responsible for the animations you have in your game. There are 2 ways to create this object:
1.Humanoid:LoadAnimation().
2.AnimationController:LoadAnimation().

For animation replication to function it is important for the Animator to be first created on the server.

The Animator object must be initially created on the server and replicated to others for animation replication in order to be shown to all. If the Animator is created locally, then any animation loaded through this animator, won’t replicate to server.

You’ll need to use the LoadAnimation() method ,and provide an Animation object [NOT its animationID]. An example:

In this section, we’ll be learning about Mouse and UserInputService ; what they are and what they do.

Mouse:
Simply our cursor. We can get the Mouse in this way:

Although Mouse is deprecated [UserInputService and ContextActionService are its replacement],
it is still supported and can be used.

This property returns the mouse’s position in the 3D space which we work with in studio.

This property returns the 3D object which the mouse is pointing to.
Notice: if you set Mouse.TargetFilter, then all the provided objects within the filter would be ignored.

This event fires whenever the mouse is moved.[Only when the mouse’s position is updated/changed].

UserInputService:
Simply a service used to detect and capture the different types of input available on a user’s device.[Console, Mobile, PC, etc].
Basically, the main purpose of this service is to provide the best experience possible to all possible devices.

This service is client-sided only. Meaning, it can only be used on the client. Which obviously means - you can only use it in LocalScript's or in ModuleScript's required by localscripts.

This property checks if the player’s device has a mouse.[ and returns true if found], if not found - it returns false.

Simply checks if the player’s device has any available touch screen.
If there is a touch screen found, you could use UserInputService - TouchEnded/TouchStarted events to operate accordingly and detect their behavior on their device.

Simply checks if the player is using a VR device. If a VR device was found, you could use some events such as UserInputService:GetUserCFrame() to do some cool stuff with it.

This event would run whenever a player begins interacting with one of the following devices [ pc,mobile,console,vr,etc].

This would fire everytime the player is changing their interaction type [ for example: Mouse button down].

Here is Part2, since I couldnt fit it in the original post because of a limit.