RBX docs

RBX docs Docs Idk

Animation Ownership

If you are experiencing issues playing your animations, or are receiving the sanitized ID error, it's likely that you're running into problems regarding ownership. Here are your options: **Set the animation's priority to Action or higher** Animations at an equal/lower priority will not play over Roblox's default animations - Action is generally r...

Before You Ask

**Before you ask a question, please do these things:** - Post relevant snippets of your code - Give the error or let us know that there isn't one - Explain what the code isn't doing - Explain what the code should be doing

Beginner Tips

- Try what you are being advised on, to avoid blindly accepting a solution that's incorrect - Try what you are taught, to gain a better understanding of what you are/will be using - Use whatever learning method (videos, documentations, experimentation, etc) works best for you regardless of other opinions - what works best for you will be the...

Breakdown

If you are seeing this tag, you are either: - Stuck in tutorial hell and cannot find a tutorial for what you want to make - New and want to know how to go about planning something specific Writing notes and breaking down what you want to make into smaller steps will help you understand: - What you need to do and - What need to be done ...

Don't Ask to Ask

Don't ask if you can ask a programming question, just go ahead and ask directly. It makes communication faster and more effective for everyone.

Factory Method

Using classes with metatables ends up being problematic for several reasons: - No standard way to define a class - Lack of support due to complexity of metatables - **Lack of type-safety and autocomplete** (without bending over backwards) Enter the factory method where you create functions that create and manipulate typed objects. This app...

Filtering Enabled

[Filtering Enabled](https://github.com/eunhalua/tags/blob/main/Filtering%20Enabled.md) is a feature that prevents changes made on the client side to replicate to the server side. This was previously an optional feature put in place by Roblox to combat exploiters but is now forced onto all experiences and cannot be toggled following Roblox's strict...

FSM

A Finite State Machine (FSM) is a computation model that's used to design systems with a finite number (limited amount) of states. At any given moment, the system can be in one of these states and can switch between states based on certain conditions or events, known as transitions. The benefit of using FSMs is to clearly separate state behaviors ...

Generalised Iteration

Since the new metamethod `__iter` was added to every table, all tables can be used as the iterator within for loops, making `pairs` and `ipairs` redundant. Here's an example: ```lua local array = {1, 2, 3} local dictionary = {a = 1, b = 2, c = 3} -- old for index, value in ipairs(array) do print(index, value) end for key, value in pairs(di...

Guard Clause

Guard clauses are assertions/if statements followed by a return to prevent the rest of the code from running. They're normally used in cases where you want to prevent data that doesn't match a certain criteria from causing issues when it is processed. Here is an example: ```lua local function add(x, y) -- if x and y aren't numbers, we return ea...

How to Print Debug

Work backwards by adding prints around the code that is failing/not running. - Print variables to see their value at the time - Print inside relevant if statements/loops to check if they're running - Print after sections of code to see if your script reaches that point

Infinite Yield

`Infinite yield possible` is a **warning** produced when you are waiting for a child to load in for potentially too long. Because it is a warning (orange text), it normally does not stop your script compared to errors (red text). If your script has stopped running due to this warning, this is caused by: - Waiting in the wrong parent - Waitin...

Joe

<img src="https://i.postimg.cc/wTxqtgLW/togif.gif" width="500" height="auto" alt="GIF">

Latency

Latency is how long something takes to happen, and is normally shown when measuring ping. When doing something, low latency means it will start faster, while high latency means it will start later. You can reduce latency by moving/(sometimes) duplicating server logic to the client and having 2 versions: - The **client-side** version will be fa...

List of Debounces

Here are a few ways to write a debounce, most want the first result unless advised otherwise: - [How to debounce](https://create.roblox.com/docs/scripting/debounce) - [How to debounce using numbers](https://github.com/cyrus01337/snippets/blob/luau/Debounces/Numerical.lua) (niche) - [How to debounce using tables](https://github.com/cyrus0133...

Local Scripts

LocalScripts run code on a player's device. Compared to server scripts that normally have one agreed location (`ServerScriptService`), there are many locations that a local script can be placed for it to run: - Inside a `Tool` - Inside a UI instance (`TextButton`, `Frame`, etc) within `StarterGui` - `StarterCharacterScripts` or `StarterPlay...

Managing Connections

Memory leaks and performance drops can become more common without properly managing your connections, which are made whenever you `:Connect()` a function to an event. To prevent these problems: - Avoid nesting connected functions, which can cause a function to be connected and run many times - Prefer `:Once()` when a connected function only n...

Memory Leaks

When your game is constantly consuming an ever-growing amount of memory, it is possible that you have a memory leak, which can be difficult to find and debug. Some things to keep in mind are: - Tables with no size limit could grow to ridiculous sizes - Nested connections without proper management will exist forever - Nested loops could cau...

Module Scripts

Module scripts (or modules) normally contain code that does not run until they have been `require`d. The code you write will run under the same restrictions as the type of script requiring it, meaning: - Modules required by local scripts will run their code as if it were a local script - Modules required by server scripts will run their code ...

New Alternative Methods

- `workspace:FindPartsInRegion3()` (24th August 2024) - [Spatial Query](https://devforum.roblox.com/t/introducing-overlapparams-new-spatial-query-api/1435720) - [`spawn()`, `delay()` and `wait()`](https://devforum.roblox.com/t/task-library-now-available/1387845) (2nd August 2021) - [`task.wait()`](https://create.roblox.com/docs/reference/engin...

No DM Help

DM help is generally not recommended. It is impossible to call out bad advice/practices in DMs, which can lead to potential misinformation and overall **bad help.** You are welcome to ask questions in public code help channels

Partitioning

When defining a lot of variables or having a lot of code as 1 block, it can be hard to read and confusing to those trying to help you. Partitioning is where you group up code by adding spacing around related blocks, allowing you to better organise what you have already defined. Here is an example with variables you normally define at the start of...

Pass by value vs reference

Variables can be passed by value or by reference depending on their data type. - Pass by value: - Numbers and other primitive data types are passed by value. When you assign a number to another variable or pass it to a function, a copy of the value is created. Any changes made to the copy do not affect the original value. - Pass by refe...

PlayerAdded in Studio

The `PlayerAdded` event in studio does not always fire on time, sometimes it is so fast that the functions you connect to the event never get the chance to run. This is only a studio issue and can be fixed by running your `PlayerAdded` function for every player currently in the game _after_ connecting your functions to the event. [Here](https://...

Prefabrication

Prefabrication is the idea of creating a template for something (i.e leaderstats) in studio. You can then clone it, make whatever changes necessary (i.e loading player data), then use it for whatever you need. The benefits for doing this: - Write way less code for the same/better results - Don't need to be a scripter to change default values...

Race Condition

When you tried to access e.g. `workspace.Baseplate`, you received an error stating that it couldn't be found. This is called a race condition and can cause confusion when `workspace.Baseplate` is shown to exist in Explorer - this is because you tried to access something before it even exists/has loaded in. You can avoid this race condition by wai...

Recommended Modules

### Datastores - [ProfileService](https://madstudioroblox.github.io/ProfileService/) - [Suphi's DataStore](https://devforum.roblox.com/t/suphis-datastore-module/2425597) ### Game Frameworks - [Knit](https://github.com/Sleitnick/Knit) ### Janitors - [Janitor](https://github.com/howmanysmall/Janitor) - [Maid](https://github.com/Quenty...

Remote Events

Remote Events are used to transfer data from one side to another, making it very useful in systems that need to send data from client to server and vice versa. Remote Events are one-way, meaning it won't wait for a response from the receiving end. **NOTE:** Any changes done by the client will not appear on the server, unless it's network-owned by...

Remote Functions

Remote Functions allow you to send and receive data from either side in a two-way manner. Unlike Remote Events, Remote Functions will wait until the function is done running or returns something. **NOTE:** Any changes done by the client will not appear on the server, unless it's network-owned by the Player. See [FilteringEnabled](https://github.c...

Rubber Duck Debugging

[Rubber duck debugging](https://en.wikipedia.org/wiki/Rubber_duck_debugging) is reading your code out loud, line by line, as if you were explaining it to somebody else. Very useful for super obvious problems. It is an effective method to find solutions to/get a better understanding of the problems a developer faces, and should be the first thing ...

Scripting Tutorials

- If you prefer to read, check the [Roblox Documentation](https://create.roblox.com/docs). - If you prefer to watch, we recommend [Hiatus](https://www.youtube.com/channel/UCwDfEvpE1uKUZH0TMx9b5Fg). - If you prefer to experiment, check [Roblox DevForum](https://devforum.roblox.com) or the **Toolbox** for pre-existing scripts. > Be sure to as...

Server Scripts

(Server) Scripts run code on a the game's server. Compared to local scripts that have many locations, server scripts can (and should) only be run in `ServerScriptService`. More info [here](https://create.roblox.com/docs/reference/engine/classes/Script).

Timing Methods

Below is a graph detailing when to use which time measurement functions: | Method | Resolution | Runs backwards | Relative to | Cost | Lags if simulation lags | 1:1 real time | Constant during frame | Usage | |--------------------------------|----------------|----------------|----------------------------|---------------------------------|---------...

Tutorial Hell

When you want to create something, instead of making an honest attempt you search for tutorials instead. This isn't just bad but also makes developing harder for you as you create more complex features in your journey. The reality is there will not be a tutorial for everything, so learning how to break down features is what you should do as it wi...

Unique Random Value

Generate a random index that ranges from 1 to the current size of the **array**, which can be used to get the first/last element, or any element between that range: ```lua -- for arrays local array = {"a", "b", "c"} local randomIndex = math.random(#array) local randomElement = array[randomIndex] -- for dictionaries - make an array of keys local ...

Unique Random Values

1. Make a copy of the **array** 2. Grab a random element from the table, then remove it from the copy 3. Repeat step 2 `n` times for `n` random elements ```lua local TOTAL_UNIQUE_ELEMENTS = 3 local array = {"foo", "bar", "baz", "quo"} local copy = table.clone(array) local uniqueElements = {} for i = 1, TOTAL_UNIQUE_ELEMENTS do local randomIndex...

VSCode Recommended Extensions

https://vscode.dev/profile/github/88af0f9d4c40dd2d63abdcbe1b2b620b

Variable

A variable is something that can be created, changed and referenced: ```lua -- Creating local myVariable = 0 -- Changing myVariable = 3 -- Referencing print(myVariable * 5) ```

What Should I Make

The best way for beginners to find out their next project is to look at the games you play and/or [brainstorm](https://images.edrawmind.com/article/how-to-use-mind-mapping-to-design-a-game/how-to-design-a-game-mind-map.png) (write down a bunch of interesting ideas based on what you like, pick the most interesting then develop it). The fastest way...

What are Frameworks

Frameworks operate on a system or specific structure that streamlines the creation of something specific. Knit is an example of a _game_ framework that simplifies making games by handling project structure, module organisation and networking for you rather than you having to implement these features yourself. Beginners should avoid them as they r...

What is return

Picture a waiter asking to take down your order. The waiter's job is to relay that information to the kitchen who will produce the meal and have it brought to your table. ```lua -- You tell the waiter what you want by calling the function with specific instructions. local function add(x, y) -- 'add' receives your 'order' (x and y). -- Af...

When to use AI

Collaborative AI tools like the Roblox Assistant, ChatGPT and extensions of these can be safely relied on for solving smaller issues like coming up with a name for something, or for a list of game ideas that fit a certain topic. As of 31st March 2024, almost all AI tools found on websites are not tools that **anyone** should rely on for real solu...

When to use Knit

Knit is **good** for people who are new to/unsure of project design, i.e organising features into folders Knit is **bad** for people that: - Already know how to structure their own projects - Prefer their own, opinionated structure or - Are new to project design but have achieved **a lot** without it **Note**: Knit will always be a learni...

When to use Paradigms

Programming paradigms, like OOP and ECS, are a choice in designing a feature or system. Just because you didn't use/pay attention to paradigms when working on your project **_does not_** mean you are behind. A common mistake for game developers is focusing on using paradigms the moment they find out about them _while_ they are in the middle of de...

Why External Editors

**The benefits of using external editors over the Roblox Studio editor:** - Snippets (built-in) - type a few characters and generate commonly-used concepts or script templates - Symbol renaming (built-in) - easily rename a variable in a specific block/scope/everywhere - Workspaces (mostly built-in) - switch between games as easily as you wo...