Local Scripts (Server vs Client) - Roblox Advanced Scripting #1 (2023)

Summary

This Roblox Advanced Scripting tutorial introduces the client-server model, crucial for game development. It explains how the server oversees game control and synchronization, while clients represent individual players. The video also demonstrates local scripts, which execute actions specific to a player without affecting others, using examples like changing a part's color on touch.

Takeaways

• 👋 Welcome to the first episode of the Roblox Advanced Scripting Tutorial series.
• 📺 It's recommended to watch the Beginner Scripting Tutorial Guide before this one.
• 🛠️ This series will cover more advanced topics in Roblox scripting.
• 🔍 The focus of this episode is on local scripts and the server-client model in Roblox.
• 🌐 Every Roblox game uses a multiplayer model called the client-server model.
• 🖥️ The server oversees the whole game and controls synchronization among players.
• 👤 The client refers to each individual player connected to the server.
• 🔁 Replication ensures all players see the same actions in the game.
• 📡 Data can be transmitted between the server and clients in different ways.
• 🔧 Local scripts are used to execute actions specific to one client without affecting others.
• 🖥️ Example given: Inserting a local script in Roblox to print 'Hello World' for a single client.
• 🎮 Example given: Changing part colors in the game for one client using a local script.
• 🛠️ How to switch perspectives between the client and server in Roblox Studio.
• 📋 Importance of understanding client-server models for developing Roblox games.
• 👨‍💻 Practical examples and walkthroughs are provided for better understanding.

Q & A

What is the main focus of the first episode of the Roblox Advanced scripting tutorial?

The first episode focuses on explaining local scripts and the server-client model, which are essential for understanding how multiplayer games work in Roblox.

Why is it recommended to watch the beginner scripting tutorial before this advanced one?

It is recommended because the advanced tutorial covers more complicated topics, and having a foundational understanding from the beginner tutorial will help in grasping these advanced concepts more effectively.

What is the client-server model in the context of Roblox games?

The client-server model is a multiplayer model where the server oversees and controls the game, and the clients are individual players who interact with the game through their perspectives.

How does the server in a Roblox game function?

The server acts as an overseer, controlling everything that happens in the game and ensuring that all players see the same events, like character movements, happening on the server.

What is a client in the context of the server-client model in Roblox?

A client in this context refers to each individual player in the game. Each player's perspective and interactions with the game are managed as a client connected to the server.

What is replication in the context of the server-client model?

Replication is the process where events that occur on the server are copied and shown to every player in the game, ensuring that all players see the same thing happening in the game.

How does transmitting data between the server and clients work in Roblox?

Data can be transmitted from one client to the server, from the server to one client, or from the server to all clients. This is used to change game elements or to show specific information to certain players.

What is an example of a client-side feature in a Roblox game?

An example of a client-side feature is the user interface, like buttons and pop-ups, which may appear differently or only on specific players' screens, depending on their actions or progress in the game.

How can you switch between the client and server perspectives in Roblox Studio?

You can switch between perspectives by clicking on the 'current client' monitor in the test ribbon in Roblox Studio, which allows you to see the game from either the player's perspective or the server's perspective.

What is a local script in Roblox and why is it used?

A local script in Roblox is a script that runs only on the client side, not being replicated to the server. It is used for actions that should only happen within a specific player's game, like changing the color of an object when stepped on.

How can you create a local script in Roblox Studio?

You can create a local script by right-clicking on an object in the Explorer window, selecting 'Local Script', and then writing the script code in the script editor that appears.

Outlines

00:00

📚 Introduction to Roblox Advanced Scripting and Client-Server Model

The video script introduces the first episode of a Roblox Advanced Scripting tutorial series, emphasizing the importance of understanding the basics before delving into more complex topics. It suggests viewers watch a beginner's guide first and mentions the goal of becoming a top-tier Roblox developer. The script discusses the necessity of understanding the local scripts and the server-client model, which are fundamental to game development on Roblox. It explains the server as an overseer of the game, controlling all in-game actions and ensuring synchronization among players, while clients represent individual players with unique perspectives and interfaces. The tutorial also highlights replication and data transmission as key aspects of the server-client model.

05:02

🔄 Exploring the Server-Client Model with In-Game Examples

This section of the script delves deeper into the server-client model, using the game Pet Simulator X to illustrate how replication and client-side features work. It demonstrates how progress in the game can be unique to each player, with examples such as accessing different areas based on individual achievements. The script also explains how user interfaces can differ from one client to another, with buttons and panels being unique to each player's perspective. The importance of understanding this model for game development is reiterated, as it impacts how developers create experiences that are specific to individual players or replicated across all players.

10:04

🛠️ Accessing Client and Server Perspectives in Roblox Studio

The script provides a practical guide on how to switch between client and server perspectives within Roblox Studio. It explains that while playing a game in test mode, developers can use the test ribbon to toggle between the current client's view and the server's view. This feature is crucial for understanding and developing game mechanics that function differently on the client and server sides. The explanation includes the default camera locations for each perspective and how developers can move around freely in the server's view, akin to using Roblox Studio's 3D world.

💬 Creating and Understanding Local Scripts in Roblox

The final part of the script introduces local scripts in Roblox, which are used to execute actions only within a specific player's game environment without being replicated on the server. It guides viewers through creating a local script attached to a part in the game, demonstrating how to change the part's color when a player touches it. The script also explains how to troubleshoot errors related to object references and how to use 'wait for child' to ensure objects are loaded before the script runs. The tutorial concludes with a visual example of a local script's effect being limited to the player's perspective, highlighting the difference between local and server-side actions in a multiplayer setting.

Keywords

💡Roblox

Roblox is an online gaming platform and game creation system that allows users to design their own games and play a wide variety of different types of games created by other users. In the context of the video, Roblox is the platform where the scripting tutorials are focused on, and it is the environment in which the viewer will be developing games.

💡Advanced scripting

Advanced scripting refers to the more complex and sophisticated techniques used in programming within the Roblox platform. The video series is aimed at those who have already completed beginner scripting tutorials and are ready to delve into more complicated topics, such as local scripts and the server-client model.

💡Server-client model

The server-client model is a fundamental concept in networked applications, including multiplayer games like those on Roblox. The server is a central system that manages the game's state and rules, while clients are individual player instances that interact with the game. The video emphasizes the importance of understanding this model for game development on Roblox.

💡Replication

In the context of the server-client model discussed in the video, replication refers to the process by which actions or changes made on the server are mirrored across all client instances. This ensures that all players see the same game state, such as a character's movement, which is crucial for maintaining a consistent gaming experience.

💡Local scripts

Local scripts in Roblox are scripts that execute on the client side and do not affect the server or other players. They are used for actions that should only be visible to a specific player, such as UI elements or local game mechanics. The video demonstrates how local scripts can be used to change the appearance of an object only for the player interacting with it.

💡Client perspective

The client perspective refers to the view of the game from the individual player's point of view. In the video, the distinction between the client and server perspectives is highlighted, showing how different players can have different experiences based on their local scripts and interactions.

💡Server perspective

The server perspective is the view of the game from the central server's point of view. It is used to manage and synchronize the game state across all clients. The video explains how developers can switch between client and server perspectives in Roblox Studio to test and develop their games.

💡Pet Simulator X

Pet Simulator X is an example game used in the video to illustrate how different players can have different experiences based on their progress in the game. It demonstrates how local scripts can affect what players see, such as unlocking new areas or accessing different UI elements.

💡UI (User Interface)

User Interface (UI) in the video refers to the elements on the screen that players interact with, such as buttons and menus. The video uses UI elements like teleport buttons to show how local scripts can create unique experiences for individual players, with different UI elements appearing based on their actions.

💡Workspace

In Roblox Studio, the workspace is the environment where game objects and scripts are created and managed. The video mentions the workspace in the context of creating a part and using local scripts to interact with it, demonstrating how game objects are manipulated within the workspace.

💡Starter Player

The Starter Player in Roblox is a template that defines the default settings for a player when they join a game. The video discusses how scripts, including local scripts, can be added to the Starter Player to customize the player's experience, such as changing the color of an object when stepped on.

Highlights

Introduction to the Roblox Advanced scripting tutorial series, emphasizing the importance of understanding the basics before proceeding.

Explanation of the client-server model as the foundation of multiplayer Roblox games, with a visual aid from the Roblox Developer Hub.

Clarification of the server's role as an overseer controlling the game's events and synchronization among players.

Description of the client as individual players, each with their unique perspective and interactions within the game.

Importance of replication in ensuring all players see the same game state, such as character movements.

Discussion on transmitting data between the server and clients, with examples of local scripts for one-way communication.

In-game demonstration of the client-server model using Pet Simulator X, showing different player perspectives and progress.

Illustration of local-sided features like user interfaces that are unique to each player's experience.

Tutorial on switching between client and server perspectives in Roblox Studio for game development.

Introduction to creating local scripts in Roblox Studio, with an example script that prints 'Hello World'.

Explanation of how local scripts run only on the client's side, not being replicated to the server.

Creation of a part in the game that changes color when touched by a player, demonstrating client-side scripting.

Use of 'wait for child' to ensure the part is loaded before the local script attempts to reference it.

Visual demonstration of a local script changing the part's color only on the client's screen, not affecting other players.

Conclusion summarizing the basics of local scripts and the client-server model, with a teaser for future tutorial topics.

Transcripts

hey thanks for stopping by welcome to the first  episode of my Roblox Advanced scripting tutorial  

series and if you haven't checked out my beginnner  scripting tutorial guide I made a few months back  

then I would highly suggest you watch that one  first before watching this one because we're  

going to be uncovering more complicated and more  advanced topics in regards to Roblox scripting  

so if you think you're ready then you're basically  on the right track to becoming a a top tier Roblox  

developer and I figured for the first episode I  think it would be important to discuss about local  

scripts and the server client model because you're  going to be knowing about this model for basically  

the entire time you're going to be developing  games on Roblox so this is going to be a very  

important one so any Roblox game regardless of  whether it allows more than one player per server  

or not follows a multiplayer model called the  client server model and to understand a little  

bit more about the client server model let me turn  your attention to to a drawing that was created by  

the Roblox developer Hub and I think this is  a really great drawing so so let's go to that  

real quick all right so there's two very important  aspects to know about for the server client model  

and the first one we'll be discussing about is the  server the best way I can describe the server is  

it's basically a reserved section of any Roblox  game that oversees the whole game itself so if I  

just drag this along really quick you can see that  the server can be represented as the game itself  

where you can see that there's three players that  are inside of the game and the camera is directed  

away from any specific player so it's kind of  like an overseer it kind of oversees the whole  

game and it controls everything that happens  with the game so that's essentially the server  

but now to describe the client side a client  is in the easiest way I can describe cribe the  

player itself each individual player so we have  one player that's over here then we have another  

player and then we have our third player that's  over here so we have three different players that  

all act as clients that are connected to the  server which oversees everything the server is  

what controls synchronization among all three  of the players that are inside of the game so  

you can see here one of the clients is one of the  players um the camera is directed towards them and  

they're seeing every that's happening in the game  from their perspective and that's going the same  

way for these other two players so there's three  important things to know about with the server  

client model and the first thing is replication  whenever something happens in the server it will  

be replicated to be shown in every single player  that are in the server if a player decides to move  

their character character then it will show to  other players that this character has also moved  

and replication is playing a factor in making sure  that all the players are seeing exactly the same  

thing that's happening on the server another  important thing is transmitting data between  

the server and also the client so usually if we  want to change something through script where it  

will be replicated only to one specific person  and not be shown to other people then we would  

use features like local scripts and I'm going to  be showing you how those work in a little bit so  

there can be different ways of transmitting data  there can be from one client to the server there  

can be from the server to one of the clients  or there can be the server sending data to all  

the clients in the server so now that I'm done  explaining how this works let me show you some  

in-game examples of how this would actually turn  out all right so I'm in a game in pet Simulator  

X and I'm being joined by my ALT account that I  just created so there's one thing to note here  

that's quite odd between the perspective  of my account and my alternative account  

so on my alternative account you can see that I  haven't unlocked the next area in pet Simulator  

X because I need to get 10,000 coins in order  to uh buy the game to get to the next area but  

on my main account uh I have lots of progress in  the game already and I already bought the gate uh  

to go to the next area so from my perspective  I can see that the gate is not there but then  

on my alternative account that's new they cannot  access the next area until until they get 10,000  

coins another example of local sided features is  user interface so for instance these buttons on  

the left side you have hoverboard teleport Auto  settings if I click on one of these it'll show a  

popup of a little panel that shows all the places  I can teleport to now if I go to my ALT account  

on their side of the screen they can't see the  popup for the teleport it's Unique to them only  

if they click the button so my ALT account can  click the button to show the teleport but then  

on my main I can X out of this and open up the  pets panel and on my alternative account it's  

still going to be on the teleport page so that's  another big example of client sided gameplay all  

right so now we know having a good understanding  of the client server model is really powerful and  

it's something we're really going to have to take  into account for anything we do when we're trying  

to develop something whether we want to show  something specific to a specific player or if  

we want to show something to all players it can  be replicated throughout uh the entire game and  

so that's always just something that you should  keep in the back of your mind but now what I want  

to do is show you how to access these different  modes when you're creating on Roblox so if we hit  

test up here and then hit play then our character  should be joining into the game like normal as  

a client so here's our character here um and in  order to flip between what you see on the client  

versus what you see on the server we're going to  go up here uh inside of the test ribbon ribbon as  

usual uh there's going to be a monitor here saying  current client so this is the current perspective  

that we're seeing in the Roblox Studio window  which is our player right here if we click on  

it we can actually see that the perspective has  changed to the server now so our camera is now on  

the default location for the the server when the  game starts up and as we can see we can freely  

move around in this server much like how we make  games in Roblox Studio using the studio 3D world  

looking um map so if I click it again then it  should go back to the perspective of the player  

and we should be able to move around freely like  so so that's how you flip between the client and  

server perspective when you're creating a game  on Roblox and to give you a little bit more of  

an understanding of what the perspective looks  like between the two so let's hit stop and now  

what we're going to do is create our first local  script on Roblox we create scripts to be able to  

give it instructions and make it do what we want  to do in Roblox but there's going to be a lot of  

times where we want the things to happen only  within a specific player and not have it be  

replicated onto the server and this is where local  scripts come in so on the right side if you have  

your Explorer window pulled up I assume you have  uh if you don't have it pulled up then you go to  

the view tab up here and then the Explorer and  properties tab should both be here so let me just  

open both of these back up um and make sure you  also have your output down here so we can see the  

results that we're about to print out so I'm just  going to right click our output and then clear it  

uh so then let's create our local script on our  Explorer let's scroll down a little bit and on our  

starter GUI we're going to hit the plus sign and  then we're going to search for a local script and  

this is what it should look like so let's click  that and then we see that it brings up the script  

editor and this pretty much looks exactly the  same as you would see when you insert a normal  

script but this time this acts as a local script  so we're not going to change anything here we're  

going to leave this as print hello world we're  going to go back to our game we're going to hit  

test and then hit play so then what should happen  is that we should see in the output uh hello world  

just like how we normally would in a uh regular  script but here's the interesting thing if we  

hit current client and switch over to the server  we can see that hello world is still here but if  

you see this colorcoded pattern here you can see  that there's actually a color here that's blue  

and then down here is a color that's green so  whenever you see an output down here where the  

color is highlighted to be blue that means that  that this little line of code ran on the client  

and not the server so green means that it ran on  the server but in this case our local script ran  

on the client as soon as one player joined the  game that's when it decided to print out onto the  

output let's now make something that will only run  on the client side and not have it be shown on the  

server so we're going to create a part where when  a player steps on it it will print out a bunch of  

stuff in the output but only on the client so with  our script that we created let's actually disable  

this uh we're not going to be using this for the  rest of the tutorial and let's insert a part so  

let's go to model up here and then let's hit part  to insert a new part into the workspace so let's  

just drag this along here let's change the scale  of it a little bit and let's change the color of  

the part down here inside of properties and let's  change the brick color to Yellow for instance um  

and now what we'll do is we'll go down here to  starter player in the Explorer so open this up  

a little bit and you will see a section called  starter character scripts so let's hit the plus  

sign here and let's create a new local script  and then let's delete this code that's been  

given to us by default so first what we'll do is  make reference to the part we'll say local part  

equals game. workpace do part so that will make  reference to the part that we just created and now  

we'll add a touched event to that part so we'll  say part. touched colon connect open parenthesis  

function open parentheses close parenthesis let's  also delete this last line here enter and then we  

will say print and then in quotations we'll say  like some random mumble jumble here okay so now  

let's go back to the game we'll hit test and we'll  hit play okay so it looks like I got an error here  

uh saying that part is not a valid member of  workspace what ended up happening was that  

the part didn't load in fast enough to catch that  there was a part in the server so so we're going  

to have to wrap this around in a wait for child so  let's delete part here and after workspace we'll  

say colon wait for child and make sure uh you  have the case sensitivity correctly then we'll  

uh say open close parentheses and inside of here  in quotes we will say part so now this is going to  

force the script to wait until part is loaded into  the game so that we can actually run whatever is  

down here so let's touch this and as you can see  on the client the part is printing out all this  

mumble jumble random nonsense this stuff isn't  being printed out on the server now it may not be  

as clear to you because the only thing we can see  here is the color difference let's do something  

more visual so we can actually understand it more  so let's hit stop go back to our local script and  

instead what we'll do is we will change the color  of the part when we step on it so let's delete  

this print statement here and let's try to write  a line that changes the color of the part so we'll  

say part do brick color equals brick color. new  and then in parentheses right here we will put in  

some quotes and say really red so now let's go  back into the game and hit play so that we can  

see our expected result that has come about with  our script so here we are and once we step on this  

plate then it should change the color to Red so as  you can see the color has now changed to red but  

if we change our client to the server we can still  see that the color is yellow because we created  

a local script that can only show what happens  with this execution when this specific player  

touches this part it will only show it happening  on on their screen and not be replicated to every  

other player that plays the game like if you just  imagine that there's going to be another player  

here another player here and then there's another  player here they're going to see that the part is  

still yellow even though you stepped on it and the  color is now red but only you see the part being  

red not anybody else so that's pretty much that  so that's pretty much the basics of local scripts  

and the server client model I will be going more  into detail about these about local scripts when  

we tackle tools that require the starter pack uh  and also gys when I start my guy tutorial series  

and things like that but this episode served as an  introduction to local scripts and the server and  

client sided models so I think I've done enough to  show that for this episode all right that's going  

to be it for this episode thanks for watching  and I will see you in the next episode take care