Understanding the Anatomy of a Module Script

Unlike other script types, a module script does not automatically include print("Hello world!"). Instead, the generated code creates a local table, which is then returned (or sent) to the calling script. Any code in the module table, such as values, functions, other tables, and pieces, will be sent within the module table.

Click here to view code image

local module = {}  -- Local table
 
return module -- Returns the table to where the script was called

The first thing you should do with any module script is to rename the script, and then update the table to match, as in the following example:

1. Rename the script with a name that describes what the code is for. This example will be TreasureManager (Figure 19.2).

   

2. Rename the table to match:

   Click here to view code image

   local TreasureManager = {}  
   
   return TreasureManager    

3. If the variables and functions only need to be used by the module script, set them using the keyword local as you normally would.

4. Add a local value named goldToGive:

   Click here to view code image

   local TreasureManager = {} 
   local goldToGive = 500 -- local variable only usable by the Module Script
   
   return TreasureManager

Adding Code That Can Be Used Anywhere

To make the code accessible from other scripts, instead of simply declaring variables and functions as you normally would, you must make sure to add it into the table so that it can be used by other scripts. To do that, reference the table using ModuleName.InsertNameHere.

Variable example

Click here to view code image

ModuleName.VariableName  =  100

Function example

Click here to view code image

function ModuleName.FunctionName()
end

To continue with the example you started earlier, now you want to add a function that can be called from any treasure chest in the game by adding a function named giveGold to the table. Do not make it local:

Click here to view code image

local TreasureManager = {}
local goldToGive = 500  

function TreasureManager.giveGold() -- Can be called from anywhere
       print(goldToGive .. "gold was added to inventory" )
end

return TreasureManager

Using a Module Script

Now that you have your module script filled, it’s time to use it. To access a module script from a LocalScript or a regular script, you need to use require(), which accepts one argument: the module script’s location in the Explorer. You also assign a variable to the result of the function (recall that a module script returns a table), as shown in the following code:

Click here to view code image

-- Getting the module script
local ServerStorage = game:GetService("ServerStorage")
local ModuleExample = require(ServerStorage.ModuleExampleMyModule)

To use the functions and variables inside of the module, use dot notation. 
-- Function example
ModuleExample.exampleFunction()

You still need to have some code in the treasure chest to call the module script. Keeping that code as light as possible makes it less likely that you have to update it later and makes your code more resistant to hacking. Call giveGold() whenever a player touches a treasure chest. Use the following steps:

1. Use a simple part or a model to act as your treasure chest. Insert a script. If you use a model, the script must go into a part.

2. Use require() to get the TreasureManager module script.

3. Add code that calls giveGold() when the player touches the treasure chest:

   Click here to view code image

   local ServerStorage = game:GetService("ServerStorage")
   local TreasureManager = require(ServerStorage.TreasureManager) -- Gets module
         script
   
   local treasureChest = script.Parent
   
   -- Gives gold when touched by a player
   local function onPartTouch(otherPart)
         local partParent = otherPart.Parent
         local humanoid = partParent:FindFirstChildWhichIsA("Humanoid")
         if humanoid then
                TreasureManager.giveGold() --Calls the function from the module
                     script
         end
   end
   
   treasureChest.Touched:Connect(onPartTouch)

Establishing Control with Settings

First, create an object that other scripts can reference when they need information regarding each stage:

1. Create a module script inside ServerStorage. You can name it anything you want, although you preferably want something memorable like GameSettings or GameInformation (Figure 19.7).

   

2. At the top of the module script, you need to set up the variables that will control how long each part of the game loop lasts. Before doing so, ask yourself these questions:

   • How long should the intermission last?

   • How long should each match/round last?

   • How many players do I need minimum for the game to function properly?

   • How much time should I have in between each “stage”?

3. Add each as a variable inside the module script.

In the following code, we have filled out a module script with answers to the preceding questions and gave them appropriate names. All times are measured in seconds:

Click here to view code image

local GameSettings = {}

GameSettings.IntermissionTime = 5
GameSettings.RoundTime = 30
GameSettings.MinimumPlayers = 2
GameSettings.TransitionTime = 3

return GameSettings

Creating Reusable Round Functions

Next, work on the script that manages the matches.

1. Create another module script inside ServerStorage named RoundManager (Figure 19.8).

   

2. Inside the RoundManager module script, add the following variables and functions that will be used to send the players to the match and reset everything when the match is over. Right now, print statements are being used as placeholders and functionality can be added later.

   Click here to view code image

   local RoundManager = {}
   
   local ServerStorage = game:GetService("ServerStorage")
   local GameSettings = require(ServerStorage:WaitForChild("GameSettings"))
   local RoundManager = {}
   
   function RoundManager.PreparePlayers()
        print("The match is beginning...")
        wait(GameSettings.TransitionTime)
   end
   
   function RoundManager.Cleanup()
        print("The match is over. Cleaning up...")
        wait(GameSettings.TransitionTime)
   end
   
   return RoundManager

Creating the Main Engine: The Game Loop

Now it’s time to work on the main engine of the system, which is the loop itself:

1. Create a regular script, this time inside ServerScriptService (Figure 19.9) so that it runs as soon as the game begins.

   

2. Set up the environment by getting everything you need: Get both module scripts from ServerStorage, as well as some other Roblox services such as Players and RunService.

   Here is the initial setup of the main loop script. Notice WaitForChild()inside the require() calls. This is to make sure the module scripts are loaded before the rest of the code in this script runs.

   Click here to view code image

   -- Services
   local RunService = game:GetService("RunService")
   local ServerStorage = game:GetService("ServerStorage")
   local Players = game:GetService("Players")
   
   -- Module Scripts
   local GameSettings = require(ServerStorage:WaitForChild("GameSettings"))
   local RoundManager = require(ServerStorage:WaitForChild("RoundManager"))
   Create the infinite loop using while true do:
   -- Main Loop
   while true do
        -- Code inside will repeat every frame
   end

3. Check to make sure that you have enough players before you attempt to begin a match.

   You can do that using an if statement that compares the number of players to the minimum number of players required to start.

   Note the # symbol, which returns the length of a table. In this case, the # will get the length of the player list, obtained through Players:GetPlayers():

   Click here to view code image

   -- Main Loop
   while true do
   -- Any code in here will be repeated every frame 
        if #Players:GetPlayers() < GameSettings.MinimumPlayers then
             wait()
        end 
   end

4. Once there are enough players, you begin the round and wait for it to end:

   Click here to view code image

   -- Main Loop
   while true do
   -- Any code in here will be repeated every frame
        if #Players:GetPlayers() < GameSettings.MinimumPlayers then
             wait()
        end
   
        wait(GameSettings.IntermissionTime)
   
        RoundManager.PreparePlayers()
   
        wait(GameSettings.RoundTime)
   
        RoundManager.Cleanup()
   end

And with that, you have the foundation for your game loop. Feel free to test it out on a live server with friends or use the testing tool with more players than minimally required in the Test tab at the top (Figure 19.10).

Quiz

1. True or False: Module scripts run by themselves.

2. True or False: Module scripts can only be placed within ServerStorage.

3. For a Module script to be used, you must use _____.

4. True or False: Local variables or functions are accessible outside of the module script.

5. True or False: Module scripts run on the client side can see everything that the server sees.

6. True or False: Module script code can be used by multiple scripts.

7. A module script returns a _____, which contains a combination of variables and functions.

8. You use module scripts as a way to better ______ your code.

Answers

1. False. Module scripts must be run or accessed by another script (such as a LocalScript or Script).

2. False. Module scripts can be placed anywhere as long as they are accessible by the script trying to use them. (See the Q&A section for best practices.)

3. For a module script to be used, you must use require.

4. False. Local variables or functions can only be accessed within the module script itself.

5. False. Module scripts on the client side can only see what the client sees (no peeking at the ServerStorage).

6. True. Module scripts can be used by any number of scripts.

7. A module script returns a table.

8. You use module scripts as a way to better organize your code.