FYI, this is an old topic since RetroStudio now has an official way of defining and executing callable functions.

Introduction

In this page, you will learn some of the ways how functions are done in RetroStudio. Due to how the scripting interface is set up, the process of creating custom functions may not be easy, especially if you are used to the way lua does it. There are few ways of creating functions, and you will learn how these methods generally work:

You will learn how each of these methods work and how they are implemented.

Method #1: Using RetroStudio's "Do Not Run" and "Execute" blocks in code

This method is by far the most secure, lua-like way to implement functions in RetroStudio. All the code is done inside one script, without the need of external modules or objects outside the script.

How to implement

Inside the scripting window, under the Misc tab and the Run section, look for the block that says "Do Not Run", and drag it to the scripting pane.
Rename the block name as any name you want to call the function.
Look for the "Execute Block" in the same pane you found the "Do Not Run" block, and copy the same exact name you put for the Do Not Run block and copy it as the value for the Execute Block.
Connect the blocks involved in the function to the "Do Not Run" block.

Advantages/Disadvantages

Method #1
Advantages	Disadvantages
All of the code is contained in one script, closest to how lua functions are created	Blocks can't pass arguments to functions directly
Most secure, no other script can call these blocks randomly from other scripts.	Execute blocks can also call other blocks within the script, not just "Do Not Run" blocks. This can be considered an advantage, however.
External modules cannot call function without external listeners	Do Not Run blocks cannot have the same name as other blocks or possibly variable names

Method #2: Using Bindable Events

This is by far another easy way to implement functions, usually if you want to add arguments to functions or if you want to call functions contained in other scripts. However, you will need to create a Bindable event into the Explorer view in order to call the function. This is useful for communication between scripts within a server if you want to communicate between the two.

How to implement

Inside the scripting window, under the Events tab and the Bindable Events section, look for the blocks that say "Fire Bindable Event" and "Receive Bindable Event", and drag it to the scripting pane.
Insert a Bindable Event into the Explorer tab, preferrably where your script(s) are located. Make sure both functions in the script point to that Bindable Event in order for it to run properly.
Connect the blocks involved in the function to the "Receive Bindable Event" block.

Advantages/Disadvantages

Method #2 (Bindable Events)
Advantages	Disadvantages
Easiest way to make custom functions with arguments	There is a limit of having 5 arguments/parameters
Useful for calling code in another script that contains the function.	Requires an external object in the explorer, meaning there is a risk of having other scripts calling/receiving the functions
More secure than using seperate value objects

Method #3: Using Remote Events

This method is similar to the method in #2, but it revolves around sending/receiving messages between the server and client.

How to implement

Inside the scripting window, under the Events tab and the Remote Events section, look for the blocks that say "Fire Remote Event (Client/All Clients/Server)" and "Receive Remote Event", and drag it to the scripting pane.
Insert a Remote Event into the Explorer tab, preferrably in the Workspace or Lighting section. Make sure both functions in the script point to that Bindable Event in order for it to run properly.
Connect the blocks involved in the function to the "Receive Remote Event" block.

Advantages/Disadvantages

Method #3 (Remote Events)
Advantages	Disadvantages
Useful for GUIs that involve communication with the server, such as buying items from the shop.	There is a limit of having 5 arguments/parameters
No peer-to-peer style communication, thus making it more secure form of communicating.	Only purpose is for client/server interaction, nothing else.

Method #4: Using Value Objects in Explorer

This method can be used if you want to pass variables as parameters. This method should be used if you want functions to run once a variable changes. It can be used for multiple parameter functions as well, but I do not recommend it for this case, as I find it to be insecure, and I would prefer Methods #1 and #2 instead.

How to implement

Inside the scripting window, under the Events tab and the General section, look for the block that says "Property Changed", and drag it to the scripting pane.
Insert a Value Object into the Explorer tab, such as BoolValue, IntValue, NumberValue, ObjectValue, StringValue, or Vector3Value. The Property Changed block must point to the Value object and the Property must be set to Value.
Connect the blocks involved in the function to the "Property Changed" block.

Advantages/Disadvantages

Method #4 (Value Objects)
Advantages	Disadvantages
Useful if you want a function to run once a variable changes.	Very Risky
Visible in Workplace.	Insecure
Can pass functions to other script	Can be inefficient in most use cases.
	Only one value per instance, and the variable type cannot be changed midway.
	Should not be the #1 go-to option if you are simply trying to pass arguments to functions.

Final thoughts

These are not the only ways to create methods, and in fact, people can tweak any of these methods to their liking once they get the hang of how RetroStudio works. Hopefully you find all of this information very useful.

In conclusion, if you are using a GUI, you should use RemoteEvents to communicate between the client and server.

If you are only calling functions within the same script, you should use method #1 and make new variables that can hold arguments. Alternatively, you could use method #2 but it would only make sense if you are calling another script.

If you are calling other scripts, I highly recommend #2 if between server scripts and #3 if it involves client-server interaction. Both methods are very similar in structure and I would prefer these over method #4.